public static async Task <SyndicationFeed> LoadAsync(XmlReader reader, Rss20FeedFormatter Rssformatter, Atom10FeedFormatter Atomformatter, CancellationToken ct)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
XmlReaderWrapper wrappedReader = XmlReaderWrapper.CreateFromReader(reader);
Atom10FeedFormatter atomSerializer = Atomformatter;
if (atomSerializer.CanRead(wrappedReader))
{
await atomSerializer.ReadFromAsync(wrappedReader, new CancellationToken());
return(atomSerializer.Feed);
}
Rss20FeedFormatter rssSerializer = Rssformatter;
if (rssSerializer.CanRead(wrappedReader))
{
await rssSerializer.ReadFromAsync(wrappedReader, new CancellationToken());
return(rssSerializer.Feed);
}
throw new XmlException(string.Format(SR.UnknownFeedXml, wrappedReader.LocalName, wrappedReader.NamespaceURI));
}
private async Task ReadDocumentAsync(XmlReaderWrapper reader)
{
try
{
await SyndicationFeedFormatter.MoveToStartElementAsync(reader);
SetDocument(await AtomPub10ServiceDocumentFormatter.ReadCategories(reader, null,
delegate()
{
return(this.CreateInlineCategoriesDocument());
},
delegate()
{
return(this.CreateReferencedCategoriesDocument());
},
this.Version,
_preserveElementExtensions,
_preserveAttributeExtensions,
_maxExtensionSize));
}
catch (FormatException e)
{
throw new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingDocument), e);
}
catch (ArgumentException e)
{
throw new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingDocument), e);
}
}
internal static async Task MoveToStartElementAsync(XmlReaderWrapper reader)
{
if (!await reader.IsStartElementAsync())
{
XmlExceptionHelper.ThrowStartElementExpected(XmlDictionaryReader.CreateDictionaryReader(reader));
}
}
protected static bool TryParseElement(XmlReader reader, ServiceDocument document, string version)
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
return(document.TryParseElement(XmlReaderWrapper.CreateFromReader(reader), version));
}
protected static bool TryParseElement(XmlReader reader, CategoriesDocument categories, string version)
{
if (categories == null)
{
throw new ArgumentNullException(nameof(categories));
}
return(categories.TryParseElement(XmlReaderWrapper.CreateFromReader(reader), version));
}
protected static bool TryParseElement(XmlReader reader, ResourceCollectionInfo collection, string version)
{
if (collection == null)
{
throw new ArgumentNullException(nameof(collection));
}
return(collection.TryParseElement(XmlReaderWrapper.CreateFromReader(reader), version));
}
protected static void LoadElementExtensions(XmlReader reader, CategoriesDocument categories, int maxExtensionSize)
{
if (categories == null)
{
throw new ArgumentNullException(nameof(categories));
}
categories.LoadElementExtensions(XmlReaderWrapper.CreateFromReader(reader), maxExtensionSize);
}
protected static bool TryParseElement(XmlReader reader, Workspace workspace, string version)
{
if (workspace == null)
{
throw new ArgumentNullException(nameof(workspace));
}
return(workspace.TryParseElement(XmlReaderWrapper.CreateFromReader(reader), version));
}
protected static void LoadElementExtensions(XmlReader reader, Workspace workspace, int maxExtensionSize)
{
if (workspace == null)
{
throw new ArgumentNullException(nameof(workspace));
}
workspace.LoadElementExtensions(XmlReaderWrapper.CreateFromReader(reader), maxExtensionSize);
}
protected static void LoadElementExtensions(XmlReader reader, ResourceCollectionInfo collection, int maxExtensionSize)
{
if (collection == null)
{
throw new ArgumentNullException(nameof(collection));
}
collection.LoadElementExtensions(XmlReaderWrapper.CreateFromReader(reader), maxExtensionSize);
}
public override Task ReadFromAsync(XmlReader reader)
{
if (!CanRead(reader))
{
throw new XmlException(SR.Format(SR.UnknownItemXml, reader.LocalName, reader.NamespaceURI));
}
return(ReadItemAsync(XmlReaderWrapper.CreateFromReader(reader)));
}
void IXmlSerializable.ReadXml(XmlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
ReadItemAsync(XmlReaderWrapper.CreateFromReader(reader)).GetAwaiter().GetResult();
}
private Task ReadXml(XmlReaderWrapper reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
return(ReadDocumentAsync(reader));
}
protected static void LoadElementExtensions(XmlReader reader, ServiceDocument document, int maxExtensionSize)
{
if (document == null)
{
throw new ArgumentNullException(nameof(document));
}
document.LoadElementExtensions(XmlReaderWrapper.CreateFromReader(reader), maxExtensionSize);
}
public override bool CanRead(XmlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
reader = XmlReaderWrapper.CreateFromReader(reader);
return(reader.IsStartElement(App10Constants.Service, App10Constants.Namespace));
}
public override Task <bool> CanReadAsync(XmlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
XmlReaderWrapper wrappedReader = XmlReaderWrapper.CreateFromReader(reader);
return(wrappedReader.IsStartElementAsync(App10Constants.Categories, App10Constants.Namespace));
}
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));
}
await ReadDocumentAsync(XmlReaderWrapper.CreateFromReader(reader));
}
public override async Task ReadFromAsync(XmlReader reader)
{
if (reader == null)
{
throw new ArgumentNullException(nameof(reader));
}
reader = XmlReaderWrapper.CreateFromReader(reader);
await reader.MoveToContentAsync().ConfigureAwait(false);
if (!CanRead(reader))
{
throw new XmlException(SR.Format(SR.UnknownDocumentXml, reader.LocalName, reader.NamespaceURI));
}
await ReadDocumentAsync(reader).ConfigureAwait(false);
}
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();
await ReadInlineCategoriesAsync(reader, inlineCategories, baseUri, version, preserveElementExtensions, preserveAttributeExtensions, maxExtensionSize);
return(inlineCategories);
}
else
{
ReferencedCategoriesDocument referencedCategories = referencedCategoriesFactory();
await ReadReferencedCategoriesAsync(reader, referencedCategories, baseUri, new Uri(link, UriKind.RelativeOrAbsolute), version, preserveElementExtensions, preserveAttributeExtensions, maxExtensionSize);
return(referencedCategories);
}
}
public async Task <XmlReader> GetReaderAsync()
{
await EnsureBufferAsync().ConfigureAwait(false);
XmlReader reader = XmlReaderWrapper.CreateFromReader(_buffer.GetReader(0));
int index = 0;
reader.ReadStartElement(Rss20Constants.ExtensionWrapperTag);
while (reader.IsStartElement())
{
if (index == _bufferElementIndex)
{
break;
}
++index;
await reader.SkipAsync().ConfigureAwait(false);
}
return(reader);
}
internal void LoadElementExtensions(XmlReaderWrapper readerOverUnparsedExtensions, int maxExtensionSize)
{
_extensions.LoadElementExtensions(readerOverUnparsedExtensions, maxExtensionSize);
}
private Task ReadItemAsync(XmlReader reader)
{
SetItem(CreateItemInstance());
return(_feedSerializer.ReadItemFromAsync(XmlReaderWrapper.CreateFromReader(XmlDictionaryReader.CreateDictionaryReader(reader)), this.Item));
}
private async Task <Workspace> ReadWorkspace(XmlReaderWrapper reader, ServiceDocument document)
{
Workspace result = CreateWorkspace(document);
result.BaseUri = document.BaseUri;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, await reader.GetValueAsync());
}
else
{
string ns = reader.NamespaceURI;
string name = reader.LocalName;
if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
{
continue;
}
string val = await reader.GetValueAsync();
if (!TryParseAttribute(name, ns, val, result, this.Version))
{
if (_preserveAttributeExtensions)
{
result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), val);
}
}
}
}
}
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
await reader.ReadStartElementAsync();
try
{
while (await reader.IsStartElementAsync())
{
if (await reader.IsStartElementAsync(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace))
{
result.Title = await new Atom10FeedFormatter().ReadTextContentFromAsync(reader, "//app:service/app:workspace/atom:title[@type]", _preserveAttributeExtensions);
}
else if (await reader.IsStartElementAsync(App10Constants.Collection, App10Constants.Namespace))
{
result.Collections.Add(ReadCollection(reader, result).Result);
}
else if (!TryParseElement(reader, result, this.Version))
{
if (_preserveElementExtensions)
{
var tuple = await SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNodeAsync(buffer, extWriter, reader, _maxExtensionSize);
buffer = tuple.Item1;
extWriter = tuple.Item2;
}
else
{
await reader.SkipAsync();
}
}
}
LoadElementExtensions(buffer, extWriter, result);
}
finally
{
if (extWriter != null)
{
extWriter.Close();
}
}
await reader.ReadEndElementAsync();
return(result);
}
private async Task ReadDocumentAsync(XmlReaderWrapper reader)
{
ServiceDocument result = CreateDocumentInstance();
try
{
await SyndicationFeedFormatter.MoveToStartElementAsync(reader);
bool elementIsEmpty = reader.IsEmptyElement;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "lang" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
result.Language = await reader.GetValueAsync();
}
else if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
result.BaseUri = new Uri(await reader.GetValueAsync(), UriKind.RelativeOrAbsolute);
}
else
{
string ns = reader.NamespaceURI;
string name = reader.LocalName;
if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
{
continue;
}
string val = await reader.GetValueAsync();
if (!TryParseAttribute(name, ns, val, result, this.Version))
{
if (_preserveAttributeExtensions)
{
result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), val);
}
}
}
}
}
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
await reader.ReadStartElementAsync();
if (!elementIsEmpty)
{
try
{
while (await reader.IsStartElementAsync())
{
if (await reader.IsStartElementAsync(App10Constants.Workspace, App10Constants.Namespace))
{
result.Workspaces.Add(ReadWorkspace(reader, result).Result);
}
else if (!TryParseElement(reader, result, this.Version))
{
if (_preserveElementExtensions)
{
var tuple = await SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNodeAsync(buffer, extWriter, reader, _maxExtensionSize);
buffer = tuple.Item1;
extWriter = tuple.Item2;
}
else
{
await reader.SkipAsync();
}
}
}
LoadElementExtensions(buffer, extWriter, result);
}
finally
{
if (extWriter != null)
{
extWriter.Close();
}
}
}
await reader.ReadEndElementAsync();
}
catch (FormatException e)
{
throw new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingDocument), e);
}
catch (ArgumentException e)
{
new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingDocument), e);
}
SetDocument(result);
}
private static async Task ReadInlineCategoriesAsync(XmlReaderWrapper reader, InlineCategoriesDocument inlineCategories, Uri baseUri, string version, bool preserveElementExtensions, bool preserveAttributeExtensions, int _maxExtensionSize)
{
inlineCategories.BaseUri = baseUri;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
inlineCategories.BaseUri = FeedUtils.CombineXmlBase(inlineCategories.BaseUri, await reader.GetValueAsync());
}
else if (reader.LocalName == "lang" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
inlineCategories.Language = await reader.GetValueAsync();
}
else if (reader.LocalName == App10Constants.Fixed && reader.NamespaceURI == string.Empty)
{
inlineCategories.IsFixed = (reader.Value == "yes");
}
else if (reader.LocalName == Atom10Constants.SchemeTag && reader.NamespaceURI == string.Empty)
{
inlineCategories.Scheme = await reader.GetValueAsync();
}
else
{
string ns = reader.NamespaceURI;
string name = reader.LocalName;
if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
{
continue;
}
string val = await reader.GetValueAsync();
if (!TryParseAttribute(name, ns, val, inlineCategories, version))
{
if (preserveAttributeExtensions)
{
inlineCategories.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), await reader.GetValueAsync());
}
}
}
}
}
await SyndicationFeedFormatter.MoveToStartElementAsync(reader);
bool isEmptyElement = reader.IsEmptyElement;
await reader.ReadStartElementAsync();
if (!isEmptyElement)
{
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
try
{
while (await reader.IsStartElementAsync())
{
if (await reader.IsStartElementAsync(Atom10Constants.CategoryTag, Atom10Constants.Atom10Namespace))
{
SyndicationCategory category = CreateCategory(inlineCategories);
await Atom10FeedFormatter.ReadCategoryAsync(reader, category, version, preserveAttributeExtensions, preserveElementExtensions, _maxExtensionSize);
if (category.Scheme == null)
{
category.Scheme = inlineCategories.Scheme;
}
inlineCategories.Categories.Add(category);
}
else if (!TryParseElement(reader, inlineCategories, version))
{
if (preserveElementExtensions)
{
var tuple = await SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNodeAsync(buffer, extWriter, reader, _maxExtensionSize);
buffer = tuple.Item1;
extWriter = tuple.Item2;
}
else
{
await reader.SkipAsync();
}
}
}
LoadElementExtensions(buffer, extWriter, inlineCategories);
}
finally
{
if (extWriter != null)
{
extWriter.Close();
}
}
await reader.ReadEndElementAsync();
}
}
private async Task <ResourceCollectionInfo> ReadCollection(XmlReaderWrapper reader, Workspace workspace)
{
ResourceCollectionInfo result = CreateCollection(workspace);
result.BaseUri = workspace.BaseUri;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, await reader.GetValueAsync());
}
else if (reader.LocalName == App10Constants.Href && reader.NamespaceURI == string.Empty)
{
result.Link = new Uri(await reader.GetValueAsync(), UriKind.RelativeOrAbsolute);
}
else
{
string ns = reader.NamespaceURI;
string name = reader.LocalName;
if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
{
continue;
}
string val = await reader.GetValueAsync();
if (!TryParseAttribute(name, ns, val, result, this.Version))
{
if (_preserveAttributeExtensions)
{
result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), val);
}
}
}
}
}
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
reader.ReadStartElement();
try
{
while (await reader.IsStartElementAsync())
{
if (await reader.IsStartElementAsync(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace))
{
result.Title = await new Atom10FeedFormatter().ReadTextContentFromAsync(reader, "//app:service/app:workspace/app:collection/atom:title[@type]", _preserveAttributeExtensions);
}
else if (await reader.IsStartElementAsync(App10Constants.Categories, App10Constants.Namespace))
{
result.Categories.Add(await ReadCategories(reader,
result.BaseUri,
delegate()
{
return(CreateInlineCategories(result));
},
delegate()
{
return(CreateReferencedCategories(result));
},
this.Version,
_preserveElementExtensions,
_preserveAttributeExtensions,
_maxExtensionSize));
}
else if (await reader.IsStartElementAsync(App10Constants.Accept, App10Constants.Namespace))
{
result.Accepts.Add(reader.ReadElementString());
}
else if (!TryParseElement(reader, result, this.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);
}
else
{
reader.Skip();
}
}
}
LoadElementExtensions(buffer, extWriter, result);
}
finally
{
if (extWriter != null)
{
extWriter.Close();
}
}
reader.ReadEndElement();
return(result);
}
private static async Task ReadReferencedCategoriesAsync(XmlReaderWrapper reader, ReferencedCategoriesDocument referencedCategories, Uri baseUri, Uri link, string version, bool preserveElementExtensions, bool preserveAttributeExtensions, int maxExtensionSize)
{
referencedCategories.BaseUri = baseUri;
referencedCategories.Link = link;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
referencedCategories.BaseUri = FeedUtils.CombineXmlBase(referencedCategories.BaseUri, await reader.GetValueAsync());
}
else if (reader.LocalName == "lang" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
{
referencedCategories.Language = await reader.GetValueAsync();
}
else if (reader.LocalName == App10Constants.Href && reader.NamespaceURI == string.Empty)
{
continue;
}
else
{
string ns = reader.NamespaceURI;
string name = reader.LocalName;
if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
{
continue;
}
string val = await reader.GetValueAsync();
if (!TryParseAttribute(name, ns, val, referencedCategories, version))
{
if (preserveAttributeExtensions)
{
referencedCategories.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), await reader.GetValueAsync());
}
}
}
}
}
reader.MoveToElement();
bool isEmptyElement = reader.IsEmptyElement;
await reader.ReadStartElementAsync();
if (!isEmptyElement)
{
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
try
{
while (await reader.IsStartElementAsync())
{
if (!TryParseElement(reader, referencedCategories, version))
{
if (preserveElementExtensions)
{
var tuple = await SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNodeAsync(buffer, extWriter, reader, maxExtensionSize);
buffer = tuple.Item1;
extWriter = tuple.Item2;
}
}
}
LoadElementExtensions(buffer, extWriter, referencedCategories);
}
finally
{
if (extWriter != null)
{
extWriter.Close();
}
}
await reader.ReadEndElementAsync();
}
}
public static XmlReaderWrapper CreateFromReader(XmlReader reader)
{
XmlReaderWrapper wrappedReader = reader as XmlReaderWrapper;
return(wrappedReader != null ? wrappedReader : new XmlReaderWrapper(reader));
}