await ReadFeedFromAsync(XmlReaderWrapper.CreateFromReader(reader), this.Feed, false);
}
- public override async Task WriteTo(XmlWriter writer)
+ public override async Task WriteToAsync(XmlWriter writer)
{
if (writer == null)
{
XmlWriterWrapper wrappedWriter = XmlWriterWrapper.CreateFromWriter(writer);
await wrappedWriter.WriteStartElementAsync(Atom10Constants.FeedTag, Atom10Constants.Atom10Namespace);
- await WriteFeed(wrappedWriter);
+ await WriteFeedAsync(wrappedWriter);
await wrappedWriter.WriteEndElementAsync();
}
}
}
- internal async Task<TextSyndicationContent> ReadTextContentFromAsync(XmlReaderWrapper reader, string context, bool preserveAttributeExtensions)
+ internal Task<TextSyndicationContent> ReadTextContentFromAsync(XmlReaderWrapper reader, string context, bool preserveAttributeExtensions)
{
string type = reader.GetAttribute(Atom10Constants.TypeTag);
- return await ReadTextContentFromHelperAsync(reader, type, context, preserveAttributeExtensions);
+ return ReadTextContentFromHelperAsync(reader, type, context, preserveAttributeExtensions);
}
internal static async Task WriteCategoryAsync(XmlWriterWrapper writer, SyndicationCategory category, string version)
await writer.WriteEndElementAsync();
}
- internal async Task ReadItemFrom(XmlReaderWrapper reader, SyndicationItem result)
+ internal async Task ReadItemFromAsync(XmlReaderWrapper reader, SyndicationItem result)
{
await ReadItemFromAsync(reader, result, null);
}
internal async Task<bool> TryParseFeedElementFromAsync(XmlReaderWrapper reader, SyndicationFeed result)
{
+ if (await reader.MoveToContentAsync() != XmlNodeType.Element)
+ {
+ return false;
+ }
string name = reader.LocalName;
string ns = reader.NamespaceURI;
internal async Task<bool> TryParseItemElementFromAsync(XmlReaderWrapper reader, SyndicationItem result)
{
+ if (await reader.MoveToContentAsync() != XmlNodeType.Element)
+ {
+ return false;
+ }
+
string name = reader.LocalName;
string ns = reader.NamespaceURI;
default:
return false;
}
+
return true;
}
+
return false;
}
internal async Task WriteFeedAuthorsToAsync(XmlWriter writer, Collection<SyndicationPerson> authors)
{
+ XmlWriterWrapper wrappedWriter = XmlWriterWrapper.CreateFromWriter(writer);
for (int i = 0; i < authors.Count; ++i)
{
SyndicationPerson p = authors[i];
- await WritePersonToAsync(XmlWriterWrapper.CreateFromWriter(writer), p, Atom10Constants.AuthorTag);
+ await WritePersonToAsync(wrappedWriter, p, Atom10Constants.AuthorTag);
}
}
internal async Task WriteFeedContributorsToAsync(XmlWriter writer, Collection<SyndicationPerson> contributors)
{
+ XmlWriterWrapper wrappedWriter = XmlWriterWrapper.CreateFromWriter(writer);
for (int i = 0; i < contributors.Count; ++i)
{
SyndicationPerson p = contributors[i];
- await WritePersonToAsync(XmlWriterWrapper.CreateFromWriter(writer), p, Atom10Constants.ContributorTag);
+ await WritePersonToAsync(wrappedWriter, p, Atom10Constants.ContributorTag);
}
}
- internal async Task WriteFeedLastUpdatedTimeToAsync(XmlWriterWrapper writer, DateTimeOffset lastUpdatedTime, bool isRequired)
+ internal Task WriteFeedLastUpdatedTimeToAsync(XmlWriterWrapper writer, DateTimeOffset lastUpdatedTime, bool isRequired)
{
if (lastUpdatedTime == DateTimeOffset.MinValue && isRequired)
{
lastUpdatedTime = DateTimeOffset.UtcNow;
}
+
if (lastUpdatedTime != DateTimeOffset.MinValue)
{
- await WriteElementAsync(writer, Atom10Constants.UpdatedTag, AsString(lastUpdatedTime));
+ return WriteElementAsync(writer, Atom10Constants.UpdatedTag, AsString(lastUpdatedTime));
}
+
+ return Task.CompletedTask;
}
internal async Task WriteItemAuthorsToAsync(XmlWriter writer, Collection<SyndicationPerson> authors)
}
}
- internal async Task WriteItemContentsAsync(XmlWriter dictWriter, SyndicationItem item)
+ internal Task WriteItemContentsAsync(XmlWriter dictWriter, SyndicationItem item)
{
- await WriteItemContentsAsync(XmlWriterWrapper.CreateFromWriter(dictWriter), item, null);
+ return WriteItemContentsAsync(XmlWriterWrapper.CreateFromWriter(dictWriter), item, null);
}
internal async Task WriteItemContributorsToAsync(XmlWriter writer, Collection<SyndicationPerson> contributors)
}
}
- internal async Task WriteItemLastUpdatedTimeToAsync(XmlWriterWrapper writer, DateTimeOffset lastUpdatedTime)
+ internal Task WriteItemLastUpdatedTimeToAsync(XmlWriterWrapper writer, DateTimeOffset lastUpdatedTime)
{
if (lastUpdatedTime == DateTimeOffset.MinValue)
{
lastUpdatedTime = DateTimeOffset.UtcNow;
}
- await writer.WriteElementStringAsync(Atom10Constants.UpdatedTag,
+ return writer.WriteElementStringAsync(Atom10Constants.UpdatedTag,
Atom10Constants.Atom10Namespace,
AsString(lastUpdatedTime));
}
dateTimeString = dateTimeString.Trim();
if (dateTimeString.Length < 20)
{
- //throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
- // new XmlException(FeedUtils.AddLineInfo(reader,
- // SR.ErrorParsingDateTime)));
- //throw new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingDateTime));
+ throw new XmlException(SR.ErrorParsingDateTime);
}
if (dateTimeString[19] == '.')
{
return new DateTimeOffset();
}
- private async Task ReadCategoryAsync(XmlReaderWrapper reader, SyndicationCategory category)
+ private Task ReadCategoryAsync(XmlReaderWrapper reader, SyndicationCategory category)
{
- await ReadCategoryAsync(reader, category, this.Version, this.PreserveAttributeExtensions, this.PreserveElementExtensions, _maxExtensionSize);
+ return ReadCategoryAsync(reader, category, this.Version, this.PreserveAttributeExtensions, this.PreserveElementExtensions, _maxExtensionSize);
}
private async Task<SyndicationCategory> ReadCategoryFromAsync(XmlReaderWrapper reader, SyndicationFeed feed)
{
await reader.ReadEndElementAsync();
}
+
return result;
}
else
}
}
-
private async Task<SyndicationFeed> ReadFeedFromAsync(XmlReaderWrapper reader, SyndicationFeed result, bool isSourceFeed)
{
await reader.MoveToContentAsync();
-
//fix to accept non contiguous items
NullNotAllowedCollection<SyndicationItem> feedItems = new NullNotAllowedCollection<SyndicationItem>();
{
if (_preserveAttributeExtensions)
{
- result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), await reader.GetValueAsync());
+ result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), val);
}
}
}
{
if (_preserveElementExtensions)
{
- if (buffer == null)
- {
- buffer = new XmlBuffer(_maxExtensionSize);
- extWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
- extWriter.WriteStartElement(Rss20Constants.ExtensionWrapperTag);
- }
-
- await XmlReaderWrapper.WriteNodeAsync(extWriter, reader, false);
+ var tuple = await CreateBufferIfRequiredAndWriteNodeAsync(buffer, extWriter, reader, _maxExtensionSize);
+ buffer = tuple.Item1;
+ extWriter = tuple.Item2;
}
else
{
await XmlReaderWrapper.WriteNodeAsync(extWriter, reader, false);
}
}
+
LoadElementExtensions(buffer, extWriter, link);
}
finally
((IDisposable)extWriter).Dispose();
}
}
+
await reader.ReadEndElementAsync();
}
+
link.Length = length;
link.MediaType = mediaType;
link.RelationshipType = relationship;
}
}
}
+
await reader.ReadStartElementAsync();
if (!isEmpty)
{
{
while (await reader.IsStartElementAsync())
{
-
string name = reader.LocalName;
string ns = reader.NamespaceURI;
bool notHandled = false;
-
switch (name)
{
case Atom10Constants.NameTag:
((IDisposable)extWriter).Dispose();
}
}
+
await reader.ReadEndElementAsync();
}
}
- private async Task<TextSyndicationContent> ReadTextContentFromAsync(XmlReaderWrapper reader, string context)
+ private Task<TextSyndicationContent> ReadTextContentFromAsync(XmlReaderWrapper reader, string context)
{
- return await ReadTextContentFromAsync(reader, context, this.PreserveAttributeExtensions);
+ return ReadTextContentFromAsync(reader, context, this.PreserveAttributeExtensions);
}
private async Task WriteCategoriesToAsync(XmlWriter writer, Collection<SyndicationCategory> categories)
}
}
- private async Task WriteFeed(XmlWriterWrapper writer)
+ private Task WriteFeedAsync(XmlWriterWrapper writer)
{
if (this.Feed == null)
{
throw new InvalidOperationException(SR.FeedFormatterDoesNotHaveFeed);
}
- await WriteFeedToAsync(writer, this.Feed, false); // isSourceFeed
+ return WriteFeedToAsync(writer, this.Feed, false); // isSourceFeed
}
private async Task WriteFeedToAsync(XmlWriterWrapper writer, SyndicationFeed feed, bool isSourceFeed)
await WriteFeedAuthorsToAsync(writer, feed.Authors);
await WriteFeedContributorsToAsync(writer, feed.Contributors);
await WriteElementAsync(writer, Atom10Constants.GeneratorTag, feed.Generator);
- //Adding icon parsing
await WriteElementAsync(writer, Atom10Constants.IconTag, feed.IconImage);
for (int i = 0; i < feed.Links.Count; ++i)
using System.Xml.Schema;
using System.Xml.Serialization;
- [TypeForwardedFrom("System.ServiceModel.Web, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
[XmlRoot(ElementName = Atom10Constants.EntryTag, Namespace = Atom10Constants.Atom10Namespace)]
public class Atom10ItemFormatter : SyndicationItemFormatter
{
return reader.IsStartElement(Atom10Constants.EntryTag, Atom10Constants.Atom10Namespace);
}
- public override async Task ReadFromAsync(XmlReader reader)
+ public override Task ReadFromAsync(XmlReader reader)
{
if (!CanRead(reader))
{
throw new XmlException(String.Format(SR.UnknownItemXml, reader.LocalName, reader.NamespaceURI));
}
- await ReadItemAsync(reader);
+ return ReadItemAsync(reader);
}
public override async Task WriteToAsync(XmlWriter writer)
return SyndicationItemFormatter.CreateItemInstance(_itemType);
}
- private async Task ReadItemAsync(XmlReader reader)
+ private Task ReadItemAsync(XmlReader reader)
{
SetItem(CreateItemInstance());
- await _feedSerializer.ReadItemFrom(XmlReaderWrapper.CreateFromReader(XmlDictionaryReader.CreateDictionaryReader(reader)), this.Item);
+ return _feedSerializer.ReadItemFromAsync(XmlReaderWrapper.CreateFromReader(XmlDictionaryReader.CreateDictionaryReader(reader)), this.Item);
}
- private async Task WriteItemAsync(XmlWriter writer)
+ private Task WriteItemAsync(XmlWriter writer)
{
if (this.Item == null)
{
throw new InvalidOperationException(SR.ItemFormatterDoesNotHaveItem);
}
XmlDictionaryWriter w = XmlDictionaryWriter.CreateDictionaryWriter(writer);
- await _feedSerializer.WriteItemContentsAsync(w, this.Item);
+ return _feedSerializer.WriteItemContentsAsync(w, this.Item);
}
}
- [TypeForwardedFrom("System.ServiceModel.Web, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
[XmlRoot(ElementName = Atom10Constants.EntryTag, Namespace = Atom10Constants.Atom10Namespace)]
public class Atom10ItemFormatter<TSyndicationItem> : Atom10ItemFormatter
where TSyndicationItem : SyndicationItem, new()
using System.Xml;
using System.Xml.Serialization;
- [TypeForwardedFrom("System.ServiceModel.Web, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
[XmlRoot(ElementName = App10Constants.Categories, Namespace = App10Constants.Namespace)]
public class AtomPub10CategoriesDocumentFormatter : CategoriesDocumentFormatter
{
{
throw new ArgumentNullException(nameof(inlineDocumentType));
}
+
if (!typeof(InlineCategoriesDocument).IsAssignableFrom(inlineDocumentType))
{
throw new ArgumentException(String.Format(SR.InvalidObjectTypePassed, nameof(inlineDocumentType), nameof(InlineCategoriesDocument)));
}
+
if (referencedDocumentType == null)
{
throw new ArgumentNullException(nameof(referencedDocumentType));
}
+
if (!typeof(ReferencedCategoriesDocument).IsAssignableFrom(referencedDocumentType))
{
throw new ArgumentException(String.Format(SR.InvalidObjectTypePassed, nameof(referencedDocumentType), nameof(ReferencedCategoriesDocument)));
}
+
_maxExtensionSize = int.MaxValue;
_preserveAttributeExtensions = true;
_preserveElementExtensions = true;
get { return App10Constants.Namespace; }
}
- public override async Task<bool> CanReadAsync(XmlReader reader)
+ public override Task<bool> CanReadAsync(XmlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
+
XmlReaderWrapper wrappedReader = XmlReaderWrapper.CreateFromReader(reader);
- return await wrappedReader.IsStartElementAsync(App10Constants.Categories, App10Constants.Namespace);
+ return wrappedReader.IsStartElementAsync(App10Constants.Categories, App10Constants.Namespace);
}
- async Task ReadXmlAsync(XmlReaderWrapper reader)
+ Task ReadXmlAsync(XmlReaderWrapper reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
- await ReadDocumentAsync(reader);
+
+ return ReadDocumentAsync(reader);
}
- async Task WriteXml(XmlWriter writer)
+ Task WriteXmlAsync(XmlWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
+
if (this.Document == null)
{
throw new InvalidOperationException(SR.DocumentFormatterDoesNotHaveDocument);
}
- await WriteDocumentAsync(writer);
+
+ return WriteDocumentAsync(writer);
}
- public override async Task ReadFrom(XmlReader reader)
+ public override async Task ReadFromAsync(XmlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
+
if (!await CanReadAsync(reader))
{
throw new XmlException(String.Format(SR.UnknownDocumentXml, reader.LocalName, reader.NamespaceURI));
{
throw new ArgumentNullException(nameof(writer));
}
+
if (this.Document == null)
{
throw new InvalidOperationException(SR.DocumentFormatterDoesNotHaveDocument);
}
+
writer.WriteStartElement(App10Constants.Prefix, App10Constants.Categories, App10Constants.Namespace);
await WriteDocumentAsync(writer);
writer.WriteEndElement();
try
{
await SyndicationFeedFormatter.MoveToStartElementAsync(reader);
- SetDocument(AtomPub10ServiceDocumentFormatter.ReadCategories(reader, null,
+ SetDocument(await AtomPub10ServiceDocumentFormatter.ReadCategories(reader, null,
delegate ()
{
return this.CreateInlineCategoriesDocument();
this.Version,
_preserveElementExtensions,
_preserveAttributeExtensions,
- _maxExtensionSize).Result);
+ _maxExtensionSize));
}
catch (FormatException e)
{
}
}
- private async Task WriteDocumentAsync(XmlWriter writer)
+ private Task WriteDocumentAsync(XmlWriter writer)
{
// declare the atom10 namespace upfront for compactness
writer.WriteAttributeString(Atom10Constants.Atom10Prefix, Atom10FeedFormatter.XmlNsNs, Atom10Constants.Atom10Namespace);
- await AtomPub10ServiceDocumentFormatter.WriteCategoriesInnerXml(writer, this.Document, null, this.Version);
+ return AtomPub10ServiceDocumentFormatter.WriteCategoriesInnerXml(writer, this.Document, null, this.Version);
}
}
}
get { return App10Constants.Namespace; }
}
- public override async Task<bool> CanReadAsync(XmlReader reader)
+ public override Task<bool> CanReadAsync(XmlReader reader)
{
if (reader == null)
{
}
XmlReaderWrapper readerWrapper = XmlReaderWrapper.CreateFromReader(reader);
- return await readerWrapper.IsStartElementAsync(App10Constants.Service, App10Constants.Namespace);
+ return readerWrapper.IsStartElementAsync(App10Constants.Service, App10Constants.Namespace);
}
- async Task ReadXml(XmlReaderWrapper reader)
+ Task ReadXml(XmlReaderWrapper reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
- await ReadDocumentAsync(reader);
+
+ return ReadDocumentAsync(reader);
}
- async Task WriteXml(XmlWriter writer)
+ Task WriteXml(XmlWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
+
if (this.Document == null)
{
throw new InvalidOperationException(SR.DocumentFormatterDoesNotHaveDocument);
}
- await WriteDocumentAsync(XmlWriterWrapper.CreateFromWriter(writer));
+
+ return WriteDocumentAsync(XmlWriterWrapper.CreateFromWriter(writer));
}
public override async Task ReadFromAsync(XmlReader reader)
{
throw new ArgumentNullException(nameof(writer));
}
+
if (this.Document == null)
{
throw new InvalidOperationException(SR.DocumentFormatterDoesNotHaveDocument);
{
WriteXmlBase(writer, baseUriToWrite);
}
+
if (!string.IsNullOrEmpty(categories.Language))
{
WriteXmlLang(writer, categories.Language);
}
+
if (categories.IsInline)
{
await WriteInlineCategoriesContentAsync(XmlWriterWrapper.CreateFromWriter(writer), (InlineCategoriesDocument)categories, version);
}
}
- private static async Task ReadInlineCategoriesAsync(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)
{
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
- inlineCategories.BaseUri = FeedUtils.CombineXmlBase(inlineCategories.BaseUri, reader.Value);
+ inlineCategories.BaseUri = FeedUtils.CombineXmlBase(inlineCategories.BaseUri, await reader.GetValueAsync());
}
else if (reader.LocalName == "lang" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
- inlineCategories.Language = reader.Value;
+ inlineCategories.Language = await reader.GetValueAsync();
}
else if (reader.LocalName == App10Constants.Fixed && reader.NamespaceURI == string.Empty)
{
}
else if (reader.LocalName == Atom10Constants.SchemeTag && reader.NamespaceURI == string.Empty)
{
- inlineCategories.Scheme = reader.Value;
+ inlineCategories.Scheme = await reader.GetValueAsync();
}
else
{
{
continue;
}
- string val = reader.Value;
+ string val = await reader.GetValueAsync();
if (!TryParseAttribute(name, ns, val, inlineCategories, version))
{
if (preserveAttributeExtensions)
{
- inlineCategories.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
+ inlineCategories.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), await reader.GetValueAsync());
}
}
}
}
}
+
await SyndicationFeedFormatter.MoveToStartElementAsync(reader);
bool isEmptyElement = reader.IsEmptyElement;
- reader.ReadStartElement();
+ await reader.ReadStartElementAsync();
if (!isEmptyElement)
{
XmlBuffer buffer = null;
if (reader.IsStartElement(Atom10Constants.CategoryTag, Atom10Constants.Atom10Namespace))
{
SyndicationCategory category = CreateCategory(inlineCategories);
- await Atom10FeedFormatter.ReadCategoryAsync(reader, category, version, preserveAttributeExtensions, preserveElementExtensions, maxExtensionSize);
+ 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)
{
- if (buffer == null)
- {
- buffer = new XmlBuffer(maxExtensionSize);
- extWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
- extWriter.WriteStartElement(Rss20Constants.ExtensionWrapperTag);
- }
-
- await XmlReaderWrapper.WriteNodeAsync(extWriter, reader, false);
+ var tuple = await SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNodeAsync(buffer, extWriter, reader, _maxExtensionSize);
+ buffer = tuple.Item1;
+ extWriter = tuple.Item2;
}
else
{
extWriter.Close();
}
}
- reader.ReadEndElement();
+
+ await reader.ReadEndElementAsync();
}
}
{
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
- referencedCategories.BaseUri = FeedUtils.CombineXmlBase(referencedCategories.BaseUri, reader.Value);
+ referencedCategories.BaseUri = FeedUtils.CombineXmlBase(referencedCategories.BaseUri, await reader.GetValueAsync());
}
else if (reader.LocalName == "lang" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
- referencedCategories.Language = reader.Value;
+ referencedCategories.Language = await reader.GetValueAsync();
}
else if (reader.LocalName == App10Constants.Href && reader.NamespaceURI == string.Empty)
{
{
continue;
}
- string val = reader.Value;
+
+ string val = await reader.GetValueAsync();
if (!TryParseAttribute(name, ns, val, referencedCategories, version))
{
if (preserveAttributeExtensions)
{
- referencedCategories.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
+ referencedCategories.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), await reader.GetValueAsync());
}
}
}
}
}
+
reader.MoveToElement();
bool isEmptyElement = reader.IsEmptyElement;
- reader.ReadStartElement();
+ await reader.ReadStartElementAsync();
if (!isEmptyElement)
{
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
try
{
- while (reader.IsStartElement())
+ while (await reader.IsStartElementAsync())
{
if (!TryParseElement(reader, referencedCategories, version))
{
if (preserveElementExtensions)
{
- if (buffer == null)
- {
- buffer = new XmlBuffer(maxExtensionSize);
- extWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
- extWriter.WriteStartElement(Rss20Constants.ExtensionWrapperTag);
- }
-
- await XmlReaderWrapper.WriteNodeAsync(extWriter, reader, false);
+ var tuple = await SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNodeAsync(buffer, extWriter, reader, maxExtensionSize);
+ buffer = tuple.Item1;
+ extWriter = tuple.Item2;
}
}
}
+
LoadElementExtensions(buffer, extWriter, referencedCategories);
}
finally
extWriter.Close();
}
}
- reader.ReadEndElement();
+
+ await reader.ReadEndElementAsync();
}
}
{
await writer.WriteAttributeStringAsync(App10Constants.Fixed, "yes");
}
+
WriteAttributeExtensions(writer, categories, version);
for (int i = 0; i < categories.Categories.Count; ++i)
{
await Atom10FeedFormatter.WriteCategoryAsync(wrappedWriter, categories.Categories[i], version);
}
+
WriteElementExtensions(writer, categories, version);
}
{
writer.WriteAttributeString(App10Constants.Href, FeedUtils.GetUriString(categories.Link));
}
+
WriteAttributeExtensions(writer, categories, version);
WriteElementExtensions(writer, categories, version);
}
{
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
- result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, reader.Value);
+ result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, await reader.GetValueAsync());
}
else if (reader.LocalName == App10Constants.Href && reader.NamespaceURI == string.Empty)
{
- result.Link = new Uri(reader.Value, UriKind.RelativeOrAbsolute);
+ result.Link = new Uri(await reader.GetValueAsync(), UriKind.RelativeOrAbsolute);
}
else
{
{
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), val);
}
}
}
}
else if (reader.IsStartElement(App10Constants.Categories, App10Constants.Namespace))
{
- result.Categories.Add(ReadCategories(reader,
+ result.Categories.Add(await ReadCategories(reader,
result.BaseUri,
delegate ()
{
this.Version,
_preserveElementExtensions,
_preserveAttributeExtensions,
- _maxExtensionSize).Result);
+ _maxExtensionSize));
}
else if (reader.IsStartElement(App10Constants.Accept, App10Constants.Namespace))
{
}
}
}
+
LoadElementExtensions(buffer, extWriter, result);
}
finally
extWriter.Close();
}
}
+
reader.ReadEndElement();
return result;
}
{
if (reader.LocalName == "lang" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
- result.Language = reader.Value;
+ result.Language = await reader.GetValueAsync();
}
else if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
- result.BaseUri = new Uri(reader.Value, UriKind.RelativeOrAbsolute);
+ result.BaseUri = new Uri(await reader.GetValueAsync(), UriKind.RelativeOrAbsolute);
}
else
{
{
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), val);
}
}
}
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
- reader.ReadStartElement();
+ await reader.ReadStartElementAsync();
if (!elementIsEmpty)
{
try
{
if (_preserveElementExtensions)
{
- if (buffer == null)
- {
- buffer = new XmlBuffer(_maxExtensionSize);
- extWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
- extWriter.WriteStartElement(Rss20Constants.ExtensionWrapperTag);
- }
-
- await XmlReaderWrapper.WriteNodeAsync(extWriter, reader, false);
+ var tuple = await SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNodeAsync(buffer, extWriter, reader, _maxExtensionSize);
+ buffer = tuple.Item1;
+ extWriter = tuple.Item2;
}
else
{
}
}
}
+
LoadElementExtensions(buffer, extWriter, result);
}
finally
}
}
}
- reader.ReadEndElement();
+
+ await reader.ReadEndElementAsync();
}
catch (FormatException e)
{
{
new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingDocument), e);
}
+
SetDocument(result);
}
{
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.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)
{
- result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
+ result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), val);
}
}
}
}
XmlBuffer buffer = null;
- XmlDictionaryWriter extWriter = null;
-
- reader.ReadStartElement();
+ XmlDictionaryWriter extWriter = null;
+ await reader.ReadStartElementAsync();
try
{
while (reader.IsStartElement())
{
if (_preserveElementExtensions)
{
- if (buffer == null)
- {
- buffer = new XmlBuffer(_maxExtensionSize);
- extWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
- extWriter.WriteStartElement(Rss20Constants.ExtensionWrapperTag);
- }
-
- await XmlReaderWrapper.WriteNodeAsync(extWriter, reader, false);
+ var tuple = await SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNodeAsync(buffer, extWriter, reader, _maxExtensionSize);
+ buffer = tuple.Item1;
+ extWriter = tuple.Item2;
}
else
{
}
}
}
+
LoadElementExtensions(buffer, extWriter, result);
}
finally
extWriter.Close();
}
}
- reader.ReadEndElement();
+
+ await reader.ReadEndElementAsync();
return result;
}
baseUri = collection.BaseUri;
WriteXmlBase(writer, baseUriToWrite);
}
+
if (collection.Link != null)
{
await writer.WriteAttributeStringAsync(App10Constants.Href, FeedUtils.GetUriString(collection.Link));
}
+
WriteAttributeExtensions(writer, collection, this.Version);
if (collection.Title != null)
{
collection.Title.WriteTo(writer, Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace);
}
+
for (int i = 0; i < collection.Accepts.Count; ++i)
{
await writer.WriteElementStringAsync(App10Constants.Prefix, App10Constants.Accept, App10Constants.Namespace, collection.Accepts[i]);
}
+
for (int i = 0; i < collection.Categories.Count; ++i)
{
await WriteCategoriesAsync(writer, collection.Categories[i], baseUri, this.Version);
}
+
WriteElementExtensions(writer, collection, this.Version);
await writer.WriteEndElementAsync();
}
{
WriteXmlLang(writer, this.Document.Language);
}
+
Uri baseUri = this.Document.BaseUri;
if (baseUri != null)
{
WriteXmlBase(writer, baseUri);
}
+
WriteAttributeExtensions(writer, this.Document, this.Version);
for (int i = 0; i < this.Document.Workspaces.Count; ++i)
{
await WriteWorkspaceAsync(writer, this.Document.Workspaces[i], baseUri);
}
+
WriteElementExtensions(writer, this.Document, this.Version);
}
baseUri = workspace.BaseUri;
WriteXmlBase(writer, baseUriToWrite);
}
+
WriteAttributeExtensions(writer, workspace, this.Version);
if (workspace.Title != null)
{
workspace.Title.WriteTo(writer, Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace);
}
+
for (int i = 0; i < workspace.Collections.Count; ++i)
{
await WriteCollectionAsync(writer, workspace.Collections[i], baseUri);
}
+
WriteElementExtensions(writer, workspace, this.Version);
await writer.WriteEndElementAsync();
}
}
- [TypeForwardedFrom("System.ServiceModel.Web, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
[XmlRoot(ElementName = App10Constants.Service, Namespace = App10Constants.Namespace)]
public class AtomPub10ServiceDocumentFormatter<TServiceDocument> : AtomPub10ServiceDocumentFormatter
where TServiceDocument : ServiceDocument, new()
using System.Threading.Tasks;
using System.Xml;
- [TypeForwardedFrom("System.ServiceModel.Web, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
public abstract class CategoriesDocument : IExtensibleSyndicationObject
{
private Uri _baseUri;
return new ReferencedCategoriesDocument(linkToCategoriesDocument);
}
- public static async Task<CategoriesDocument> Load(XmlReader reader)
+ public static async Task<CategoriesDocument> LoadAsync(XmlReader reader)
{
AtomPub10CategoriesDocumentFormatter formatter = new AtomPub10CategoriesDocumentFormatter();
- await formatter.ReadFrom(reader);
+ await formatter.ReadFromAsync(reader);
return formatter.Document;
}
{ get; }
public abstract Task<bool> CanReadAsync(XmlReader reader);
- public abstract Task ReadFrom(XmlReader reader);
+ public abstract Task ReadFromAsync(XmlReader reader);
public abstract Task WriteTo(XmlWriter writer);
protected virtual InlineCategoriesDocument CreateInlineCategoriesDocument()
{
throw new ArgumentNullException(nameof(readerOverUnparsedExtensions));
}
+
if (maxExtensionSize < 0)
{
throw new ArgumentOutOfRangeException(nameof(maxExtensionSize));
{
throw new ArgumentNullException(nameof(writer));
}
+
if (_attributeExtensions != null)
{
foreach (XmlQualifiedName qname in _attributeExtensions.Keys)
{
throw new ArgumentNullException(nameof(writer));
}
+
if (_elementExtensions != null)
{
_elementExtensions.WriteTo(writer);
NoIPEndpointsFoundForHost=No IPEndpoints were found for host {0}.
DnsResolveFailed=No DNS entries exist for host {0}.
+InvalidSkipHours=The hour can't be lower than 0 or greater than 23
RequiredAttributeMissing=Attribute '{0}' is required on element '{1}'.
UnsupportedCryptoAlgorithm=Crypto algorithm {0} not supported in this context.
CustomCryptoAlgorithmIsNotValidHashAlgorithm=The custom crypto algorithm '{0}' obtained using CryptoConfig is not a valid or supported hash algorithm.
using Microsoft.ServiceModel.Syndication.Resources;
using System;
using System.Collections.Generic;
+ using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Globalization;
using System.Text;
private bool _serializeExtensionsAsAtom;
//Custom Parsers
-
// value, localname , ns , result
- public Func<string, string, string, string> stringParser;
- public Func<string, string, string, DateTimeOffset> dateParser;
- public Func<string, string, string, Uri> uriParser;
- /*
- * title
- * link
- * description
- * language
- * date
- *
- */
-
- private string StringParserAction(string value, string localName, string ns)
+ public Func<string, string, string, string> StringParser { get; set; } = DefaultStringParser;
+ public Func<string, string, string, DateTimeOffset> DateParser { get; set; } = DefaultDateParser;
+ public Func<string, string, string, Uri> UriParser { get; set; } = DefaultUriParser;
+
+ static private string DefaultStringParser(string value, string localName, string ns)
{
return value;
}
- private Uri UriParserAction(string value, string localName, string ns)
+ static private Uri DefaultUriParser(string value, string localName, string ns)
{
- return new Uri(value);
+ return new Uri(value, UriKind.RelativeOrAbsolute);
}
-
-
private async Task<bool> OnReadImage(XmlReaderWrapper reader, SyndicationFeed result)
{
await reader.ReadStartElementAsync();
{
if (await reader.IsStartElementAsync(Rss20Constants.UrlTag, Rss20Constants.Rss20Namespace))
{
- //result.ImageUrl = new Uri(await reader.ReadElementStringAsync(), UriKind.RelativeOrAbsolute);
- result.ImageUrl = uriParser(await reader.ReadElementStringAsync(), reader.LocalName, reader.NamespaceURI);
+ result.ImageUrl = UriParser(await reader.ReadElementStringAsync(), reader.LocalName, reader.NamespaceURI);
}
else if(await reader.IsStartElementAsync("link",Rss20Constants.Rss20Namespace))
{
- //result.ImageLink = new Uri(await reader.ReadElementStringAsync(), UriKind.RelativeOrAbsolute);
- result.ImageLink = uriParser(await reader.ReadElementStringAsync(), reader.LocalName, reader.NamespaceURI);
+ result.ImageLink = UriParser(await reader.ReadElementStringAsync(), reader.LocalName, reader.NamespaceURI);
}
else if (await reader.IsStartElementAsync("title", Rss20Constants.Rss20Namespace))
{
- //result.ImageTitle = new TextSyndicationContent(await reader.ReadElementStringAsync());
- result.ImageTitle = new TextSyndicationContent(stringParser(await reader.ReadElementStringAsync(), reader.LocalName, reader.NamespaceURI));
+ result.ImageTitle = new TextSyndicationContent(StringParser(await reader.ReadElementStringAsync(), reader.LocalName, reader.NamespaceURI));
}
}
await reader.ReadEndElementAsync(); // image
return true;
}
-
-
-
- private void LoadDefaultParsers()
- {
- stringParser = StringParserAction;
- dateParser = DateParserAction;
- uriParser = UriParserAction;
- }
public Rss20FeedFormatter()
: this(typeof(SyndicationFeed))
{
- //Setting default parsers
- LoadDefaultParsers();
}
public Rss20FeedFormatter(Type feedTypeToCreate)
_preserveAttributeExtensions = true;
_atomSerializer = new Atom10FeedFormatter(feedTypeToCreate);
_feedType = feedTypeToCreate;
-
- LoadDefaultParsers();
}
public Rss20FeedFormatter(SyndicationFeed feedToWrite)
return reader.IsStartElement(Rss20Constants.RssTag, Rss20Constants.Rss20Namespace);
}
- public override async Task ReadFromAsync(XmlReader reader)
+ public override Task ReadFromAsync(XmlReader reader)
{
if (!CanRead(reader))
{
}
SetFeed(CreateFeedInstance());
- await ReadXmlAsync(XmlReaderWrapper.CreateFromReader(reader), this.Feed);
+ return ReadXmlAsync(XmlReaderWrapper.CreateFromReader(reader), this.Feed);
}
- async Task WriteXml(XmlWriter writer)
+ private Task WriteXmlAsync(XmlWriter writer)
{
if (writer == null)
{
throw new ArgumentNullException(nameof(writer));
}
- await WriteFeedAsync(XmlWriterWrapper.CreateFromWriter( writer) );
+ return WriteFeedAsync(XmlWriterWrapper.CreateFromWriter( writer) );
}
- public override async Task WriteTo(XmlWriter writer)
+ public override async Task WriteToAsync(XmlWriter writer)
{
if (writer == null)
{
_atomSerializer.SetFeed(this.Feed);
}
- async Task ReadItemFromAsync(XmlReaderWrapper reader, SyndicationItem result, Uri feedBaseUri)
+ private async Task ReadItemFromAsync(XmlReaderWrapper reader, SyndicationItem result, Uri feedBaseUri)
{
result.BaseUri = feedBaseUri;
await reader.MoveToContentAsync();
result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, await reader.GetValueAsync());
continue;
}
+
if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
{
continue;
}
+
string val = await reader.GetValueAsync();
if (!TryParseAttribute(name, ns, val, result, this.Version))
{
switch (reader.LocalName)
{
case Rss20Constants.TitleTag:
- //result.Title = new TextSyndicationContent(await reader.ReadElementStringAsync());
- result.Title = new TextSyndicationContent(stringParser(await reader.ReadElementStringAsync(),reader.LocalName,reader.NamespaceURI));
+ result.Title = new TextSyndicationContent(StringParser(await reader.ReadElementStringAsync(),reader.LocalName,reader.NamespaceURI));
break;
case Rss20Constants.LinkTag:
break;
case Rss20Constants.DescriptionTag:
- //result.Summary = new TextSyndicationContent(await reader.ReadElementStringAsync());
- result.Summary = new TextSyndicationContent(stringParser(await reader.ReadElementStringAsync(), reader.LocalName, reader.NamespaceURI));
+ result.Summary = new TextSyndicationContent(StringParser(await reader.ReadElementStringAsync(), reader.LocalName, reader.NamespaceURI));
break;
case Rss20Constants.AuthorTag:
case Rss20Constants.EnclosureTag:
result.Links.Add(await ReadMediaEnclosureAsync(reader, result.BaseUri));
-
break;
case Rss20Constants.GuidTag:
isPermalink = false;
}
- result.Id = stringParser(await reader.ReadElementStringAsync(),reader.LocalName,reader.NamespaceURI);//await reader.ReadElementStringAsync();
+ result.Id = StringParser(await reader.ReadElementStringAsync(),reader.LocalName,reader.NamespaceURI);
if (isPermalink)
{
fallbackAlternateLink = result.Id;
string str = await reader.ReadStringAsync();
if (!string.IsNullOrEmpty(str))
{
- result.PublishDate = dateParser(str, reader.LocalName, reader.NamespaceURI);
+ result.PublishDate = DateParser(str, reader.LocalName, reader.NamespaceURI);
}
await reader.ReadEndElementAsync();
string val = await reader.GetValueAsync();
if (name == Rss20Constants.UrlTag && ns == Rss20Constants.Rss20Namespace)
{
- feed.Links.Add(SyndicationLink.CreateSelfLink(new Uri(val, UriKind.RelativeOrAbsolute)));
+ feed.Links.Add(SyndicationLink.CreateSelfLink(UriParser(val, Rss20Constants.UrlTag,ns)));
}
else if (!FeedUtils.IsXmlns(name, ns))
{
}
}
}
- string feedTitle = stringParser(await reader.ReadElementStringAsync(), reader.LocalName, reader.NamespaceURI); //await reader.ReadElementStringAsync();
+ string feedTitle = StringParser(await reader.ReadElementStringAsync(), reader.LocalName, reader.NamespaceURI); //await reader.ReadElementStringAsync();
feed.Title = new TextSyndicationContent(feedTitle);
result.SourceFeed = feed;
}
}
- internal async Task ReadItemFromAsync(XmlReaderWrapper reader, SyndicationItem result)
+ internal Task ReadItemFromAsync(XmlReaderWrapper reader, SyndicationItem result)
{
- await ReadItemFromAsync(reader, result, null);
+ return ReadItemFromAsync(reader, result, null);
}
- internal async Task WriteItemContentsAsync(XmlWriter writer, SyndicationItem item)
+ internal Task WriteItemContentsAsync(XmlWriter writer, SyndicationItem item)
{
XmlWriterWrapper writerWrapped = XmlWriterWrapper.CreateFromWriter(writer);
- await WriteItemContentsAsync(writerWrapped, item, null);
+ return WriteItemContentsAsync(writerWrapped, item, null);
}
protected override SyndicationFeed CreateFeedInstance()
if(reader.LocalName == Rss20Constants.HourTag)
{
- string val = stringParser(await reader.ReadElementStringAsync(), Rss20Constants.HourTag, Rss20Constants.Rss20Namespace);
+ string val = StringParser(await reader.ReadElementStringAsync(), Rss20Constants.HourTag, Rss20Constants.Rss20Namespace);
int hour = int.Parse(val);
- if (hour < 0 || hour > 24)
+ if (hour < 0 || hour > 23)
{
- throw new ArgumentException("The hour can't be lower than 0 or greater than 24");
+ throw new ArgumentException("The hour can't be lower than 0 or greater than 23");
}
result.SkipHours.Add(hour);
{
if (reader.LocalName == Rss20Constants.DayTag)
{
- string day = stringParser(await reader.ReadElementStringAsync(), reader.LocalName, Rss20Constants.Rss20Namespace);
+ string day = StringParser(await reader.ReadElementStringAsync(), reader.LocalName, Rss20Constants.Rss20Namespace);
result.SkipDays.Add(day);
}
else
await reader.ReadEndElementAsync();
}
- public static void RemoveExtraWhiteSpaceAtStart(StringBuilder stringBuilder)
+ internal static void RemoveExtraWhiteSpaceAtStart(StringBuilder stringBuilder)
{
int i = 0;
while (i < stringBuilder.Length)
}
}
- public static void ReplaceMultipleWhiteSpaceWithSingleWhiteSpace(StringBuilder builder)
+ private static void ReplaceMultipleWhiteSpaceWithSingleWhiteSpace(StringBuilder builder)
{
int index = 0;
int whiteSpaceStart = -1;
++index;
}
// we have already trimmed the start and end so there cannot be a trail of white spaces in the end
+ Debug.Assert(builder.Length == 0 || builder[builder.Length - 1] != ' ', "The string builder doesnt end in a white space");
}
private string AsString(DateTimeOffset dateTime)
}
}
}
- //string uri = stringParser(await reader.ReadElementStringAsync(), reader.LocalName, reader.NamespaceURI);
- link.Uri = uriParser(await reader.ReadElementStringAsync(), reader.LocalName, reader.NamespaceURI);//new Uri(uri, UriKind.RelativeOrAbsolute);
+ link.Uri = UriParser(await reader.ReadElementStringAsync(), reader.LocalName, reader.NamespaceURI);//new Uri(uri, UriKind.RelativeOrAbsolute);
return link;
}
- async Task<SyndicationCategory> ReadCategoryAsync(XmlReaderWrapper reader, SyndicationFeed feed)
+ private async Task<SyndicationCategory> ReadCategoryAsync(XmlReaderWrapper reader, SyndicationFeed feed)
{
SyndicationCategory result = CreateCategory(feed);
await ReadCategoryAsync(reader, result);
return result;
}
- async Task ReadCategoryAsync(XmlReaderWrapper reader, SyndicationCategory category)
+ private async Task ReadCategoryAsync(XmlReaderWrapper reader, SyndicationCategory category)
{
bool isEmpty = reader.IsEmptyElement;
if (reader.HasAttributes)
if (!isEmpty)
{
- category.Name = stringParser(await reader.ReadStringAsync(), reader.LocalName, reader.NamespaceURI);//await reader.ReadStringAsync();
+ category.Name = StringParser(await reader.ReadStringAsync(), reader.LocalName, reader.NamespaceURI);
await reader.ReadEndElementAsync();
}
}
- async Task<SyndicationCategory> ReadCategoryAsync(XmlReaderWrapper reader, SyndicationItem item)
+ private async Task<SyndicationCategory> ReadCategoryAsync(XmlReaderWrapper reader, SyndicationItem item)
{
SyndicationCategory result = CreateCategory(item);
await ReadCategoryAsync(reader, result);
return result;
}
-
- async Task<SyndicationLink> ReadMediaEnclosureAsync(XmlReaderWrapper reader, Uri baseUri)
+
+ private async Task<SyndicationLink> ReadMediaEnclosureAsync(XmlReaderWrapper reader, Uri baseUri)
{
SyndicationLink link = new SyndicationLink();
link.BaseUri = baseUri;
return link;
}
-
- async Task<SyndicationPerson> ReadPersonAsync(XmlReaderWrapper reader, SyndicationFeed feed)
+
+ private async Task<SyndicationPerson> ReadPersonAsync(XmlReaderWrapper reader, SyndicationFeed feed)
{
SyndicationPerson result = CreatePerson(feed);
await ReadPersonAsync(reader, result);
return result;
}
-
- async Task ReadPersonAsync(XmlReaderWrapper reader, SyndicationPerson person)
+
+ private async Task ReadPersonAsync(XmlReaderWrapper reader, SyndicationPerson person)
{
bool isEmpty = reader.IsEmptyElement;
if (reader.HasAttributes)
await reader.ReadStartElementAsync();
if (!isEmpty)
{
- string email = stringParser(await reader.ReadStringAsync(),reader.LocalName,reader.NamespaceURI);// await reader.ReadStringAsync();
+ string email = StringParser(await reader.ReadStringAsync(),reader.LocalName,reader.NamespaceURI);
await reader.ReadEndElementAsync();
person.Email = email;
}
}
-
- async Task<SyndicationPerson> ReadPersonAsync(XmlReaderWrapper reader, SyndicationItem item)
+
+ private async Task<SyndicationPerson> ReadPersonAsync(XmlReaderWrapper reader, SyndicationItem item)
{
SyndicationPerson result = CreatePerson(item);
await ReadPersonAsync(reader, result);
return result;
}
- bool checkTextInput(SyndicationTextInput textInput)
+ private bool checkTextInput(SyndicationTextInput textInput)
{
//All textInput items are required, we check if all items were instantiated.
return (textInput.Description != null && textInput.title != null && textInput.name != null && textInput.link != null);
while (await reader.IsStartElementAsync())
{
string name = reader.LocalName;
- val = stringParser(await reader.ReadElementStringAsync(), name, Rss20Constants.Rss20Namespace);
+ val = StringParser(await reader.ReadElementStringAsync(), name, Rss20Constants.Rss20Namespace);
switch (name)
{
break;
case Rss20Constants.LinkTag:
- textInput.link = new SyndicationLink(uriParser(val, name, reader.NamespaceURI));
+ textInput.link = new SyndicationLink(UriParser(val, name, reader.NamespaceURI));
break;
case Rss20Constants.NameTag:
string version = reader.GetAttribute(Rss20Constants.VersionTag, Rss20Constants.Rss20Namespace);
if (version != Rss20Constants.Version)
{
- throw new NotSupportedException();
+ throw new NotSupportedException(FeedUtils.AddLineInfo(reader, (String.Format(SR.UnsupportedRssVersion, version))));
}
if (reader.AttributeCount > 1)
}
bool areAllItemsRead = true;
- //bool readItemsAtLeastOnce = false;
await reader.ReadStartElementAsync(Rss20Constants.ChannelTag, Rss20Constants.Rss20Namespace);
XmlBuffer buffer = null;
switch (reader.LocalName)
{
case Rss20Constants.TitleTag:
- //result.Title = new TextSyndicationContent(await reader.ReadElementStringAsync());
- result.Title = new TextSyndicationContent(stringParser(await reader.ReadElementStringAsync(),reader.LocalName,Rss20Constants.Rss20Namespace));
+ result.Title = new TextSyndicationContent(StringParser(await reader.ReadElementStringAsync(), reader.LocalName, Rss20Constants.Rss20Namespace));
break;
case Rss20Constants.LinkTag:
- //string link =
result.Links.Add(await ReadAlternateLinkAsync(reader, result.BaseUri));
break;
case Rss20Constants.DescriptionTag:
- result.Description = new TextSyndicationContent(stringParser(await reader.ReadElementStringAsync(), reader.LocalName, Rss20Constants.Rss20Namespace));
+ result.Description = new TextSyndicationContent(StringParser(await reader.ReadElementStringAsync(), reader.LocalName, Rss20Constants.Rss20Namespace));
break;
case Rss20Constants.LanguageTag:
- result.Language = stringParser(await reader.ReadElementStringAsync(), reader.LocalName, Rss20Constants.Rss20Namespace);
+ result.Language = StringParser(await reader.ReadElementStringAsync(), reader.LocalName, Rss20Constants.Rss20Namespace);
break;
case Rss20Constants.CopyrightTag:
- result.Copyright = new TextSyndicationContent(stringParser(await reader.ReadElementStringAsync(), reader.LocalName, Rss20Constants.Rss20Namespace));
+ result.Copyright = new TextSyndicationContent(StringParser(await reader.ReadElementStringAsync(), reader.LocalName, Rss20Constants.Rss20Namespace));
break;
case Rss20Constants.ManagingEditorTag:
if (!string.IsNullOrEmpty(str))
{
- result.LastUpdatedTime = dateParser(str, reader.LocalName, reader.NamespaceURI); // DateFromString(str, reader);
+ result.LastUpdatedTime = DateParser(str, reader.LocalName, reader.NamespaceURI);
}
await reader.ReadEndElementAsync();
break;
case Rss20Constants.GeneratorTag:
- result.Generator = stringParser(await reader.ReadElementStringAsync(), reader.LocalName, Rss20Constants.Rss20Namespace);
+ result.Generator = StringParser(await reader.ReadElementStringAsync(), reader.LocalName, Rss20Constants.Rss20Namespace);
break;
case Rss20Constants.ImageTag:
{
- await OnReadImage(reader,result);
+ await OnReadImage(reader, result);
break;
}
{
feedItems.Add(await ReadItemAsync(reader, result));
}
-
+
areAllItemsRead = true;
break;
//Optional tags
case Rss20Constants.DocumentationTag:
- result.Documentation = await ReadAlternateLinkAsync(reader,result.BaseUri);
+ result.Documentation = await ReadAlternateLinkAsync(reader, result.BaseUri);
break;
case Rss20Constants.TimeToLiveTag:
- string value = stringParser(await reader.ReadElementStringAsync(), Rss20Constants.TimeToLiveTag, Rss20Constants.Rss20Namespace);
+ string value = StringParser(await reader.ReadElementStringAsync(), Rss20Constants.TimeToLiveTag, Rss20Constants.Rss20Namespace);
int timeToLive = int.Parse(value);
result.TimeToLive = timeToLive;
break;
// break;
case Rss20Constants.TextInputTag:
- await readTextInputTag(reader,result);
+ await readTextInputTag(reader, result);
break;
case Rss20Constants.SkipHoursTag:
- await ReadSkipHoursAsync(reader,result);
+ await ReadSkipHoursAsync(reader, result);
break;
case Rss20Constants.SkipDaysTag:
- await ReadSkipDaysAsync(reader,result);
+ await ReadSkipDaysAsync(reader, result);
break;
default:
//asign all read items to feed items.
result.Items = feedItems;
- LoadElementExtensions(buffer, extWriter, result);
+ LoadElementExtensions(buffer, extWriter, result);
+ }
+ catch (FormatException e)
+ {
+ throw new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingFeed), e);
+ }
+ catch (ArgumentException e)
+ {
+ throw new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingFeed), e);
}
finally
{
await reader.ReadEndElementAsync(); // channel
await reader.ReadEndElementAsync(); // rss
}
- }
+ }
private async Task WriteAlternateLinkAsync(XmlWriterWrapper writer, SyndicationLink link, Uri baseUri)
{
await writer.WriteEndElementAsync(); // image
}
-
- //new optional spec items go here
-
+ //Optional spec items
//time to live
if(this.Feed.TimeToLive != 0)
{
await writer.WriteEndElementAsync();
}
-
- //========================
if (_serializeExtensionsAsAtom)
{
await _atomSerializer.WriteElementAsync(writer, Atom10Constants.IdTag, this.Feed.Id);
}
// Custom parsers
- public DateTimeOffset DateParserAction(string dateTimeString, string localName, string ns)
+ public static DateTimeOffset DefaultDateParser(string dateTimeString, string localName, string ns)
{
bool parsed = false;
//try
public async Task SaveAsAtom10(XmlWriter writer)
{
- await this.GetAtom10Formatter().WriteTo(writer);
+ await this.GetAtom10Formatter().WriteToAsync(writer);
}
public async Task SaveAsRss20(XmlWriter writer)
{
- await this.GetRss20Formatter().WriteTo(writer);
+ await this.GetRss20Formatter().WriteToAsync(writer);
}
protected internal virtual SyndicationCategory CreateCategory()
return String.Format(CultureInfo.CurrentCulture, "{0}, SyndicationVersion={1}", this.GetType(), this.Version);
}
- public abstract Task WriteTo(XmlWriter writer);
+ public abstract Task WriteToAsync(XmlWriter writer);
internal static protected SyndicationCategory CreateCategory(SyndicationFeed feed)
{
Rss20FeedFormatter rssf = new Rss20FeedFormatter(sf);
// *** EXECUTE *** \\
- rssf.WriteTo(xmlw).GetAwaiter().GetResult();
+ rssf.WriteToAsync(xmlw).GetAwaiter().GetResult();
xmlw.Close();
// *** VALIDATE *** \\
//Write the same feed that was read.
XmlWriter xmlw = XmlWriter.Create(path);
Rss20FeedFormatter atomFeed = new Rss20FeedFormatter(sf);
- atomFeed.WriteTo(xmlw).GetAwaiter().GetResult();
+ atomFeed.WriteToAsync(xmlw).GetAwaiter().GetResult();
xmlw.Close();
// *** VALIDATE *** \\
settingsWriter.Async = true;
XmlWriter xmlw = XmlWriter.Create(path,settingsWriter);
Rss20FeedFormatter atomFeed = new Rss20FeedFormatter(sf);
- Task write = atomFeed.WriteTo(xmlw);
+ Task write = atomFeed.WriteToAsync(xmlw);
Task.WhenAll(write);
//Write the same feed that was read.
XmlWriter xmlw = XmlWriter.Create(path);
Atom10FeedFormatter atomFeed = new Atom10FeedFormatter(sf);
- atomFeed.WriteTo(xmlw).GetAwaiter().GetResult();
+ atomFeed.WriteToAsync(xmlw).GetAwaiter().GetResult();
xmlw.Close();
// *** VALIDATE *** \\
XmlWriter xmlw = XmlWriter.Create(path,writerSettings);
Atom10FeedFormatter atomFeed = new Atom10FeedFormatter(sf);
- Task write = atomFeed.WriteTo(xmlw);
+ Task write = atomFeed.WriteToAsync(xmlw);
Task.WhenAll(write);
xmlw.Close();
// *** EXECUTE *** \\
- Task rss = rssff.WriteTo(xmlwRss);
+ Task rss = rssff.WriteToAsync(xmlwRss);
Task.WaitAll(rss);
xmlwRss.Close();
- atomf.WriteTo(xmlwAtom).GetAwaiter().GetResult(); ;
+ atomf.WriteToAsync(xmlwAtom).GetAwaiter().GetResult(); ;
xmlwAtom.Close();
// *** ASSERT *** \\
try
{
// *** EXECUTE *** \\
- rssff.WriteTo(writer).GetAwaiter().GetResult(); ;
+ rssff.WriteToAsync(writer).GetAwaiter().GetResult(); ;
writer.Close();
// *** ASSERT *** \\
// *** SETUP *** \\
Rss20FeedFormatter rssformatter = new Rss20FeedFormatter();
- rssformatter.stringParser = (val, name, ns) =>
+ rssformatter.StringParser = (val, name, ns) =>
{
switch (name)
{
projects / platform / upstream / dotnet / runtime.git / commitdiff