Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

1343 lines
56 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Syndication
{
using System;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.Globalization;
using System.Text;
using System.Xml;
using System.Xml.Serialization;
using System.Diagnostics.CodeAnalysis;
using System.Xml.Schema;
using System.Collections;
using DiagnosticUtility = System.ServiceModel.DiagnosticUtility;
using System.ServiceModel.Channels;
using System.Runtime.CompilerServices;
[TypeForwardedFrom("System.ServiceModel.Web, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
[XmlRoot(ElementName = Atom10Constants.FeedTag, Namespace = Atom10Constants.Atom10Namespace)]
public class Atom10FeedFormatter : SyndicationFeedFormatter, IXmlSerializable
{
internal static readonly TimeSpan zeroOffset = new TimeSpan(0, 0, 0);
internal const string XmlNs = "http://www.w3.org/XML/1998/namespace";
internal const string XmlNsNs = "http://www.w3.org/2000/xmlns/";
static readonly XmlQualifiedName Atom10Href = new XmlQualifiedName(Atom10Constants.HrefTag, string.Empty);
static readonly XmlQualifiedName Atom10Label = new XmlQualifiedName(Atom10Constants.LabelTag, string.Empty);
static readonly XmlQualifiedName Atom10Length = new XmlQualifiedName(Atom10Constants.LengthTag, string.Empty);
static readonly XmlQualifiedName Atom10Relative = new XmlQualifiedName(Atom10Constants.RelativeTag, string.Empty);
static readonly XmlQualifiedName Atom10Scheme = new XmlQualifiedName(Atom10Constants.SchemeTag, string.Empty);
static readonly XmlQualifiedName Atom10Term = new XmlQualifiedName(Atom10Constants.TermTag, string.Empty);
static readonly XmlQualifiedName Atom10Title = new XmlQualifiedName(Atom10Constants.TitleTag, string.Empty);
static readonly XmlQualifiedName Atom10Type = new XmlQualifiedName(Atom10Constants.TypeTag, string.Empty);
static readonly UriGenerator idGenerator = new UriGenerator();
const string Rfc3339LocalDateTimeFormat = "yyyy-MM-ddTHH:mm:sszzz";
const string Rfc3339UTCDateTimeFormat = "yyyy-MM-ddTHH:mm:ssZ";
Type feedType;
int maxExtensionSize;
bool preserveAttributeExtensions;
bool preserveElementExtensions;
public Atom10FeedFormatter()
: this(typeof(SyndicationFeed))
{
}
public Atom10FeedFormatter(Type feedTypeToCreate)
: base()
{
if (feedTypeToCreate == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("feedTypeToCreate");
}
if (!typeof(SyndicationFeed).IsAssignableFrom(feedTypeToCreate))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("feedTypeToCreate",
SR.GetString(SR.InvalidObjectTypePassed, "feedTypeToCreate", "SyndicationFeed"));
}
this.maxExtensionSize = int.MaxValue;
this.preserveAttributeExtensions = this.preserveElementExtensions = true;
this.feedType = feedTypeToCreate;
}
public Atom10FeedFormatter(SyndicationFeed feedToWrite)
: base(feedToWrite)
{
// No need to check that the parameter passed is valid - it is checked by the c'tor of the base class
this.maxExtensionSize = int.MaxValue;
preserveAttributeExtensions = preserveElementExtensions = true;
this.feedType = feedToWrite.GetType();
}
public bool PreserveAttributeExtensions
{
get { return this.preserveAttributeExtensions; }
set { this.preserveAttributeExtensions = value; }
}
public bool PreserveElementExtensions
{
get { return this.preserveElementExtensions; }
set { this.preserveElementExtensions = value; }
}
public override string Version
{
get { return SyndicationVersions.Atom10; }
}
protected Type FeedType
{
get
{
return this.feedType;
}
}
public override bool CanRead(XmlReader reader)
{
if (reader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
}
return reader.IsStartElement(Atom10Constants.FeedTag, Atom10Constants.Atom10Namespace);
}
[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "The IXmlSerializable implementation is only for exposing under WCF DataContractSerializer. The funcionality is exposed to derived class through the ReadFrom\\WriteTo methods")]
XmlSchema IXmlSerializable.GetSchema()
{
return null;
}
[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "The IXmlSerializable implementation is only for exposing under WCF DataContractSerializer. The funcionality is exposed to derived class through the ReadFrom\\WriteTo methods")]
void IXmlSerializable.ReadXml(XmlReader reader)
{
if (reader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
}
TraceFeedReadBegin();
ReadFeed(reader);
TraceFeedReadEnd();
}
[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "The IXmlSerializable implementation is only for exposing under WCF DataContractSerializer. The funcionality is exposed to derived class through the ReadFrom\\WriteTo methods")]
void IXmlSerializable.WriteXml(XmlWriter writer)
{
if (writer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("writer");
}
TraceFeedWriteBegin();
WriteFeed(writer);
TraceFeedWriteEnd();
}
public override void ReadFrom(XmlReader reader)
{
TraceFeedReadBegin();
if (!CanRead(reader))
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.UnknownFeedXml, reader.LocalName, reader.NamespaceURI)));
}
ReadFeed(reader);
TraceFeedReadEnd();
}
public override void WriteTo(XmlWriter writer)
{
if (writer == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("writer");
}
TraceFeedWriteBegin();
writer.WriteStartElement(Atom10Constants.FeedTag, Atom10Constants.Atom10Namespace);
WriteFeed(writer);
writer.WriteEndElement();
TraceFeedWriteEnd();
}
internal static void ReadCategory(XmlReader reader, SyndicationCategory category, string version, bool preserveAttributeExtensions, bool preserveElementExtensions, int maxExtensionSize)
{
MoveToStartElement(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)
{
category.Scheme = reader.Value;
}
else if (reader.LocalName == Atom10Constants.LabelTag && reader.NamespaceURI == string.Empty)
{
category.Label = reader.Value;
}
else
{
string ns = reader.NamespaceURI;
string name = reader.LocalName;
if (FeedUtils.IsXmlns(name, ns))
{
continue;
}
string val = reader.Value;
if (!TryParseAttribute(name, ns, val, category, version))
{
if (preserveAttributeExtensions)
{
category.AttributeExtensions.Add(new XmlQualifiedName(name, ns), val);
}
else
{
TraceSyndicationElementIgnoredOnRead(reader);
}
}
}
}
}
if (!isEmpty)
{
reader.ReadStartElement();
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
try
{
while (reader.IsStartElement())
{
if (TryParseElement(reader, category, version))
{
continue;
}
else if (!preserveElementExtensions)
{
TraceSyndicationElementIgnoredOnRead(reader);
reader.Skip();
}
else
{
CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, maxExtensionSize);
}
}
LoadElementExtensions(buffer, extWriter, category);
}
finally
{
if (extWriter != null)
{
((IDisposable) extWriter).Dispose();
}
}
reader.ReadEndElement();
}
else
{
reader.ReadStartElement();
}
}
internal static TextSyndicationContent ReadTextContentFrom(XmlReader reader, string context, bool preserveAttributeExtensions)
{
string type = reader.GetAttribute(Atom10Constants.TypeTag);
return ReadTextContentFromHelper(reader, type, context, preserveAttributeExtensions);
}
internal static void WriteCategory(XmlWriter writer, SyndicationCategory category, string version)
{
writer.WriteStartElement(Atom10Constants.CategoryTag, Atom10Constants.Atom10Namespace);
WriteAttributeExtensions(writer, category, version);
string categoryName = category.Name ?? string.Empty;
if (!category.AttributeExtensions.ContainsKey(Atom10Term))
{
writer.WriteAttributeString(Atom10Constants.TermTag, categoryName);
}
if (!string.IsNullOrEmpty(category.Label) && !category.AttributeExtensions.ContainsKey(Atom10Label))
{
writer.WriteAttributeString(Atom10Constants.LabelTag, category.Label);
}
if (!string.IsNullOrEmpty(category.Scheme) && !category.AttributeExtensions.ContainsKey(Atom10Scheme))
{
writer.WriteAttributeString(Atom10Constants.SchemeTag, category.Scheme);
}
WriteElementExtensions(writer, category, version);
writer.WriteEndElement();
}
internal void ReadItemFrom(XmlReader reader, SyndicationItem result)
{
ReadItemFrom(reader, result, null);
}
internal bool TryParseFeedElementFrom(XmlReader reader, SyndicationFeed result)
{
if (reader.IsStartElement(Atom10Constants.AuthorTag, Atom10Constants.Atom10Namespace))
{
result.Authors.Add(ReadPersonFrom(reader, result));
}
else if (reader.IsStartElement(Atom10Constants.CategoryTag, Atom10Constants.Atom10Namespace))
{
result.Categories.Add(ReadCategoryFrom(reader, result));
}
else if (reader.IsStartElement(Atom10Constants.ContributorTag, Atom10Constants.Atom10Namespace))
{
result.Contributors.Add(ReadPersonFrom(reader, result));
}
else if (reader.IsStartElement(Atom10Constants.GeneratorTag, Atom10Constants.Atom10Namespace))
{
result.Generator = reader.ReadElementString();
}
else if (reader.IsStartElement(Atom10Constants.IdTag, Atom10Constants.Atom10Namespace))
{
result.Id = reader.ReadElementString();
}
else if (reader.IsStartElement(Atom10Constants.LinkTag, Atom10Constants.Atom10Namespace))
{
result.Links.Add(ReadLinkFrom(reader, result));
}
else if (reader.IsStartElement(Atom10Constants.LogoTag, Atom10Constants.Atom10Namespace))
{
result.ImageUrl = new Uri(reader.ReadElementString(), UriKind.RelativeOrAbsolute);
}
else if (reader.IsStartElement(Atom10Constants.RightsTag, Atom10Constants.Atom10Namespace))
{
result.Copyright = ReadTextContentFrom(reader, "//atom:feed/atom:rights[@type]");
}
else if (reader.IsStartElement(Atom10Constants.SubtitleTag, Atom10Constants.Atom10Namespace))
{
result.Description = ReadTextContentFrom(reader, "//atom:feed/atom:subtitle[@type]");
}
else if (reader.IsStartElement(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace))
{
result.Title = ReadTextContentFrom(reader, "//atom:feed/atom:title[@type]");
}
else if (reader.IsStartElement(Atom10Constants.UpdatedTag, Atom10Constants.Atom10Namespace))
{
reader.ReadStartElement();
result.LastUpdatedTime = DateFromString(reader.ReadString(), reader);
reader.ReadEndElement();
}
else
{
return false;
}
return true;
}
internal bool TryParseItemElementFrom(XmlReader reader, SyndicationItem result)
{
if (reader.IsStartElement(Atom10Constants.AuthorTag, Atom10Constants.Atom10Namespace))
{
result.Authors.Add(ReadPersonFrom(reader, result));
}
else if (reader.IsStartElement(Atom10Constants.CategoryTag, Atom10Constants.Atom10Namespace))
{
result.Categories.Add(ReadCategoryFrom(reader, result));
}
else if (reader.IsStartElement(Atom10Constants.ContentTag, Atom10Constants.Atom10Namespace))
{
result.Content = ReadContentFrom(reader, result);
}
else if (reader.IsStartElement(Atom10Constants.ContributorTag, Atom10Constants.Atom10Namespace))
{
result.Contributors.Add(ReadPersonFrom(reader, result));
}
else if (reader.IsStartElement(Atom10Constants.IdTag, Atom10Constants.Atom10Namespace))
{
result.Id = reader.ReadElementString();
}
else if (reader.IsStartElement(Atom10Constants.LinkTag, Atom10Constants.Atom10Namespace))
{
result.Links.Add(ReadLinkFrom(reader, result));
}
else if (reader.IsStartElement(Atom10Constants.PublishedTag, Atom10Constants.Atom10Namespace))
{
reader.ReadStartElement();
result.PublishDate = DateFromString(reader.ReadString(), reader);
reader.ReadEndElement();
}
else if (reader.IsStartElement(Atom10Constants.RightsTag, Atom10Constants.Atom10Namespace))
{
result.Copyright = ReadTextContentFrom(reader, "//atom:feed/atom:entry/atom:rights[@type]");
}
else if (reader.IsStartElement(Atom10Constants.SourceFeedTag, Atom10Constants.Atom10Namespace))
{
reader.ReadStartElement();
result.SourceFeed = ReadFeedFrom(reader, new SyndicationFeed(), true); // isSourceFeed
reader.ReadEndElement();
}
else if (reader.IsStartElement(Atom10Constants.SummaryTag, Atom10Constants.Atom10Namespace))
{
result.Summary = ReadTextContentFrom(reader, "//atom:feed/atom:entry/atom:summary[@type]");
}
else if (reader.IsStartElement(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace))
{
result.Title = ReadTextContentFrom(reader, "//atom:feed/atom:entry/atom:title[@type]");
}
else if (reader.IsStartElement(Atom10Constants.UpdatedTag, Atom10Constants.Atom10Namespace))
{
reader.ReadStartElement();
result.LastUpdatedTime = DateFromString(reader.ReadString(), reader);
reader.ReadEndElement();
}
else
{
return false;
}
return true;
}
internal void WriteContentTo(XmlWriter writer, string elementName, SyndicationContent content)
{
if (content != null)
{
content.WriteTo(writer, elementName, Atom10Constants.Atom10Namespace);
}
}
internal void WriteElement(XmlWriter writer, string elementName, string value)
{
if (value != null)
{
writer.WriteElementString(elementName, Atom10Constants.Atom10Namespace, value);
}
}
internal void WriteFeedAuthorsTo(XmlWriter writer, Collection<SyndicationPerson> authors)
{
for (int i = 0; i < authors.Count; ++i)
{
SyndicationPerson p = authors[i];
WritePersonTo(writer, p, Atom10Constants.AuthorTag);
}
}
internal void WriteFeedContributorsTo(XmlWriter writer, Collection<SyndicationPerson> contributors)
{
for (int i = 0; i < contributors.Count; ++i)
{
SyndicationPerson p = contributors[i];
WritePersonTo(writer, p, Atom10Constants.ContributorTag);
}
}
internal void WriteFeedLastUpdatedTimeTo(XmlWriter writer, DateTimeOffset lastUpdatedTime, bool isRequired)
{
if (lastUpdatedTime == DateTimeOffset.MinValue && isRequired)
{
lastUpdatedTime = DateTimeOffset.UtcNow;
}
if (lastUpdatedTime != DateTimeOffset.MinValue)
{
WriteElement(writer, Atom10Constants.UpdatedTag, AsString(lastUpdatedTime));
}
}
internal void WriteItemAuthorsTo(XmlWriter writer, Collection<SyndicationPerson> authors)
{
for (int i = 0; i < authors.Count; ++i)
{
SyndicationPerson p = authors[i];
WritePersonTo(writer, p, Atom10Constants.AuthorTag);
}
}
internal void WriteItemContents(XmlWriter dictWriter, SyndicationItem item)
{
WriteItemContents(dictWriter, item, null);
}
internal void WriteItemContributorsTo(XmlWriter writer, Collection<SyndicationPerson> contributors)
{
for (int i = 0; i < contributors.Count; ++i)
{
SyndicationPerson p = contributors[i];
WritePersonTo(writer, p, Atom10Constants.ContributorTag);
}
}
internal void WriteItemLastUpdatedTimeTo(XmlWriter writer, DateTimeOffset lastUpdatedTime)
{
if (lastUpdatedTime == DateTimeOffset.MinValue)
{
lastUpdatedTime = DateTimeOffset.UtcNow;
}
writer.WriteElementString(Atom10Constants.UpdatedTag,
Atom10Constants.Atom10Namespace,
AsString(lastUpdatedTime));
}
internal void WriteLink(XmlWriter writer, SyndicationLink link, Uri baseUri)
{
writer.WriteStartElement(Atom10Constants.LinkTag, Atom10Constants.Atom10Namespace);
Uri baseUriToWrite = FeedUtils.GetBaseUriToWrite(baseUri, link.BaseUri);
if (baseUriToWrite != null)
{
writer.WriteAttributeString("xml", "base", XmlNs, FeedUtils.GetUriString(baseUriToWrite));
}
link.WriteAttributeExtensions(writer, SyndicationVersions.Atom10);
if (!string.IsNullOrEmpty(link.RelationshipType) && !link.AttributeExtensions.ContainsKey(Atom10Relative))
{
writer.WriteAttributeString(Atom10Constants.RelativeTag, link.RelationshipType);
}
if (!string.IsNullOrEmpty(link.MediaType) && !link.AttributeExtensions.ContainsKey(Atom10Type))
{
writer.WriteAttributeString(Atom10Constants.TypeTag, link.MediaType);
}
if (!string.IsNullOrEmpty(link.Title) && !link.AttributeExtensions.ContainsKey(Atom10Title))
{
writer.WriteAttributeString(Atom10Constants.TitleTag, link.Title);
}
if (link.Length != 0 && !link.AttributeExtensions.ContainsKey(Atom10Length))
{
writer.WriteAttributeString(Atom10Constants.LengthTag, Convert.ToString(link.Length, CultureInfo.InvariantCulture));
}
if (!link.AttributeExtensions.ContainsKey(Atom10Href))
{
writer.WriteAttributeString(Atom10Constants.HrefTag, FeedUtils.GetUriString(link.Uri));
}
link.WriteElementExtensions(writer, SyndicationVersions.Atom10);
writer.WriteEndElement();
}
protected override SyndicationFeed CreateFeedInstance()
{
return SyndicationFeedFormatter.CreateFeedInstance(this.feedType);
}
protected virtual SyndicationItem ReadItem(XmlReader reader, SyndicationFeed feed)
{
if (feed == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("feed");
}
if (reader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
}
SyndicationItem item = CreateItem(feed);
TraceItemReadBegin();
ReadItemFrom(reader, item, feed.BaseUri);
TraceItemReadEnd();
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(XmlReader reader, SyndicationFeed feed, out bool areAllItemsRead)
{
if (feed == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("feed");
}
if (reader == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
}
NullNotAllowedCollection<SyndicationItem> items = new NullNotAllowedCollection<SyndicationItem>();
while (reader.IsStartElement(Atom10Constants.EntryTag, Atom10Constants.Atom10Namespace))
{
items.Add(ReadItem(reader, feed));
}
areAllItemsRead = true;
return items;
}
protected virtual void WriteItem(XmlWriter writer, SyndicationItem item, Uri feedBaseUri)
{
TraceItemWriteBegin();
writer.WriteStartElement(Atom10Constants.EntryTag, Atom10Constants.Atom10Namespace);
WriteItemContents(writer, item, feedBaseUri);
writer.WriteEndElement();
TraceItemWriteEnd();
}
protected virtual void WriteItems(XmlWriter writer, IEnumerable<SyndicationItem> items, Uri feedBaseUri)
{
if (items == null)
{
return;
}
foreach (SyndicationItem item in items)
{
this.WriteItem(writer, item, feedBaseUri);
}
}
static TextSyndicationContent ReadTextContentFromHelper(XmlReader reader, string type, string context, bool preserveAttributeExtensions)
{
if (string.IsNullOrEmpty(type))
{
type = Atom10Constants.PlaintextType;
}
TextSyndicationContentKind kind;
switch (type)
{
case Atom10Constants.PlaintextType:
kind = TextSyndicationContentKind.Plaintext;
break;
case Atom10Constants.HtmlType:
kind = TextSyndicationContentKind.Html;
break;
case Atom10Constants.XHtmlType:
kind = TextSyndicationContentKind.XHtml;
break;
default:
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(FeedUtils.AddLineInfo(reader, SR.GetString(SR.Atom10SpecRequiresTextConstruct, context, type))));
}
Dictionary<XmlQualifiedName, string> attrs = null;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == Atom10Constants.TypeTag && reader.NamespaceURI == string.Empty)
{
continue;
}
string ns = reader.NamespaceURI;
string name = reader.LocalName;
if (FeedUtils.IsXmlns(name, ns))
{
continue;
}
if (preserveAttributeExtensions)
{
string value = reader.Value;
if (attrs == null)
{
attrs = new Dictionary<XmlQualifiedName, string>();
}
attrs.Add(new XmlQualifiedName(name, ns), value);
}
else
{
TraceSyndicationElementIgnoredOnRead(reader);
}
}
}
reader.MoveToElement();
string val = (kind == TextSyndicationContentKind.XHtml) ? reader.ReadInnerXml() : reader.ReadElementString();
TextSyndicationContent result = new TextSyndicationContent(val, kind);
if (attrs != null)
{
foreach (XmlQualifiedName attr in attrs.Keys)
{
if (!FeedUtils.IsXmlns(attr.Name, attr.Namespace))
{
result.AttributeExtensions.Add(attr, attrs[attr]);
}
}
}
return result;
}
string AsString(DateTimeOffset dateTime)
{
if (dateTime.Offset == zeroOffset)
{
return dateTime.ToUniversalTime().ToString(Rfc3339UTCDateTimeFormat, CultureInfo.InvariantCulture);
}
else
{
return dateTime.ToString(Rfc3339LocalDateTimeFormat, CultureInfo.InvariantCulture);
}
}
DateTimeOffset DateFromString(string dateTimeString, XmlReader reader)
{
dateTimeString = dateTimeString.Trim();
if (dateTimeString.Length < 20)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new XmlException(FeedUtils.AddLineInfo(reader,
SR.ErrorParsingDateTime)));
}
if (dateTimeString[19] == '.')
{
// remove any fractional seconds, we choose to ignore them
int i = 20;
while (dateTimeString.Length > i && char.IsDigit(dateTimeString[i]))
{
++i;
}
dateTimeString = dateTimeString.Substring(0, 19) + dateTimeString.Substring(i);
}
DateTimeOffset localTime;
if (DateTimeOffset.TryParseExact(dateTimeString, Rfc3339LocalDateTimeFormat,
CultureInfo.InvariantCulture.DateTimeFormat,
DateTimeStyles.None, out localTime))
{
return localTime;
}
DateTimeOffset utcTime;
if (DateTimeOffset.TryParseExact(dateTimeString, Rfc3339UTCDateTimeFormat,
CultureInfo.InvariantCulture.DateTimeFormat,
DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, out utcTime))
{
return utcTime;
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
new XmlException(FeedUtils.AddLineInfo(reader,
SR.ErrorParsingDateTime)));
}
void ReadCategory(XmlReader reader, SyndicationCategory category)
{
ReadCategory(reader, category, this.Version, this.PreserveAttributeExtensions, this.PreserveElementExtensions, this.maxExtensionSize);
}
SyndicationCategory ReadCategoryFrom(XmlReader reader, SyndicationFeed feed)
{
SyndicationCategory result = CreateCategory(feed);
ReadCategory(reader, result);
return result;
}
SyndicationCategory ReadCategoryFrom(XmlReader reader, SyndicationItem item)
{
SyndicationCategory result = CreateCategory(item);
ReadCategory(reader, result);
return result;
}
SyndicationContent ReadContentFrom(XmlReader reader, SyndicationItem item)
{
MoveToStartElement(reader);
string type = reader.GetAttribute(Atom10Constants.TypeTag, string.Empty);
SyndicationContent result;
if (TryParseContent(reader, item, type, this.Version, out result))
{
return result;
}
if (string.IsNullOrEmpty(type))
{
type = Atom10Constants.PlaintextType;
}
string src = reader.GetAttribute(Atom10Constants.SourceTag, string.Empty);
if (string.IsNullOrEmpty(src) && type != Atom10Constants.PlaintextType && type != Atom10Constants.HtmlType && type != Atom10Constants.XHtmlType)
{
return new XmlSyndicationContent(reader);
}
if (!string.IsNullOrEmpty(src))
{
result = new UrlSyndicationContent(new Uri(src, UriKind.RelativeOrAbsolute), type);
bool isEmpty = reader.IsEmptyElement;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == Atom10Constants.TypeTag && reader.NamespaceURI == string.Empty)
{
continue;
}
else if (reader.LocalName == Atom10Constants.SourceTag && reader.NamespaceURI == string.Empty)
{
continue;
}
else if (!FeedUtils.IsXmlns(reader.LocalName, reader.NamespaceURI))
{
if (this.preserveAttributeExtensions)
{
result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
}
else
{
TraceSyndicationElementIgnoredOnRead(reader);
}
}
}
}
reader.ReadStartElement();
if (!isEmpty)
{
reader.ReadEndElement();
}
return result;
}
else
{
return ReadTextContentFromHelper(reader, type, "//atom:feed/atom:entry/atom:content[@type]", this.preserveAttributeExtensions);
}
}
void ReadFeed(XmlReader reader)
{
SetFeed(CreateFeedInstance());
ReadFeedFrom(reader, this.Feed, false);
}
SyndicationFeed ReadFeedFrom(XmlReader reader, SyndicationFeed result, bool isSourceFeed)
{
reader.MoveToContent();
try
{
bool elementIsEmpty = false;
if (!isSourceFeed)
{
MoveToStartElement(reader);
elementIsEmpty = reader.IsEmptyElement;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "lang" && reader.NamespaceURI == XmlNs)
{
result.Language = reader.Value;
}
else if (reader.LocalName == "base" && reader.NamespaceURI == XmlNs)
{
result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, reader.Value);
}
else
{
string ns = reader.NamespaceURI;
string name = reader.LocalName;
if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
{
continue;
}
string val = reader.Value;
if (!TryParseAttribute(name, ns, val, result, this.Version))
{
if (this.preserveAttributeExtensions)
{
result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
}
else
{
TraceSyndicationElementIgnoredOnRead(reader);
}
}
}
}
}
reader.ReadStartElement();
}
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
bool areAllItemsRead = true;
bool readItemsAtLeastOnce = false;
if (!elementIsEmpty)
{
try
{
while (reader.IsStartElement())
{
if (TryParseFeedElementFrom(reader, result))
{
// nothing, we parsed something, great
}
else if (reader.IsStartElement(Atom10Constants.EntryTag, Atom10Constants.Atom10Namespace) && !isSourceFeed)
{
if (readItemsAtLeastOnce)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR.GetString(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
{
if (!TryParseElement(reader, result, this.Version))
{
if (this.preserveElementExtensions)
{
CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, this.maxExtensionSize);
}
else
{
TraceSyndicationElementIgnoredOnRead(reader);
reader.Skip();
}
}
}
}
LoadElementExtensions(buffer, extWriter, result);
}
finally
{
if (extWriter != null)
{
((IDisposable)extWriter).Dispose();
}
}
}
if (!isSourceFeed && areAllItemsRead)
{
reader.ReadEndElement(); // feed
}
}
catch (FormatException e)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingFeed), e));
}
catch (ArgumentException e)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingFeed), e));
}
return result;
}
void ReadItemFrom(XmlReader reader, SyndicationItem result, Uri feedBaseUri)
{
try
{
result.BaseUri = feedBaseUri;
MoveToStartElement(reader);
bool isEmpty = reader.IsEmptyElement;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
string ns = reader.NamespaceURI;
string name = reader.LocalName;
if (name == "base" && ns == XmlNs)
{
result.BaseUri = FeedUtils.CombineXmlBase(result.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 (this.preserveAttributeExtensions)
{
result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
}
else
{
TraceSyndicationElementIgnoredOnRead(reader);
}
}
}
}
reader.ReadStartElement();
if (!isEmpty)
{
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
try
{
while (reader.IsStartElement())
{
if (TryParseItemElementFrom(reader, result))
{
// nothing, we parsed something, great
}
else
{
if (!TryParseElement(reader, result, this.Version))
{
if (this.preserveElementExtensions)
{
CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, this.maxExtensionSize);
}
else
{
TraceSyndicationElementIgnoredOnRead(reader);
reader.Skip();
}
}
}
}
LoadElementExtensions(buffer, extWriter, result);
}
finally
{
if (extWriter != null)
{
((IDisposable) extWriter).Dispose();
}
}
reader.ReadEndElement(); // item
}
}
catch (FormatException e)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingItem), e));
}
catch (ArgumentException e)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingItem), e));
}
}
void ReadLink(XmlReader reader, SyndicationLink link, Uri baseUri)
{
bool isEmpty = reader.IsEmptyElement;
string mediaType = null;
string relationship = null;
string title = null;
string lengthStr = null;
string val = null;
link.BaseUri = baseUri;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
if (reader.LocalName == "base" && reader.NamespaceURI == XmlNs)
{
link.BaseUri = FeedUtils.CombineXmlBase(link.BaseUri, reader.Value);
}
else if (reader.LocalName == Atom10Constants.TypeTag && 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;
}
else if (reader.LocalName == Atom10Constants.HrefTag && reader.NamespaceURI == string.Empty)
{
val = reader.Value;
}
else if (!FeedUtils.IsXmlns(reader.LocalName, reader.NamespaceURI))
{
if (this.preserveAttributeExtensions)
{
link.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
}
else
{
TraceSyndicationElementIgnoredOnRead(reader);
}
}
}
}
long length = 0;
if (!string.IsNullOrEmpty(lengthStr))
{
length = Convert.ToInt64(lengthStr, CultureInfo.InvariantCulture.NumberFormat);
}
reader.ReadStartElement();
if (!isEmpty)
{
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
try
{
while (reader.IsStartElement())
{
if (TryParseElement(reader, link, this.Version))
{
continue;
}
else if (!this.preserveElementExtensions)
{
SyndicationFeedFormatter.TraceSyndicationElementIgnoredOnRead(reader);
reader.Skip();
}
else
{
CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, this.maxExtensionSize);
}
}
LoadElementExtensions(buffer, extWriter, link);
}
finally
{
if (extWriter != null)
{
((IDisposable) extWriter).Dispose();
}
}
reader.ReadEndElement();
}
link.Length = length;
link.MediaType = mediaType;
link.RelationshipType = relationship;
link.Title = title;
link.Uri = (val != null) ? new Uri(val, UriKind.RelativeOrAbsolute) : null;
}
SyndicationLink ReadLinkFrom(XmlReader reader, SyndicationFeed feed)
{
SyndicationLink result = CreateLink(feed);
ReadLink(reader, result, feed.BaseUri);
return result;
}
SyndicationLink ReadLinkFrom(XmlReader reader, SyndicationItem item)
{
SyndicationLink result = CreateLink(item);
ReadLink(reader, result, item.BaseUri);
return result;
}
SyndicationPerson ReadPersonFrom(XmlReader reader, SyndicationFeed feed)
{
SyndicationPerson result = CreatePerson(feed);
ReadPersonFrom(reader, result);
return result;
}
SyndicationPerson ReadPersonFrom(XmlReader reader, SyndicationItem item)
{
SyndicationPerson result = CreatePerson(item);
ReadPersonFrom(reader, result);
return result;
}
void ReadPersonFrom(XmlReader reader, SyndicationPerson result)
{
bool isEmpty = reader.IsEmptyElement;
if (reader.HasAttributes)
{
while (reader.MoveToNextAttribute())
{
string ns = reader.NamespaceURI;
string name = reader.LocalName;
if (FeedUtils.IsXmlns(name, ns))
{
continue;
}
string val = reader.Value;
if (!TryParseAttribute(name, ns, val, result, this.Version))
{
if (this.preserveAttributeExtensions)
{
result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
}
else
{
TraceSyndicationElementIgnoredOnRead(reader);
}
}
}
}
reader.ReadStartElement();
if (!isEmpty)
{
XmlBuffer buffer = null;
XmlDictionaryWriter extWriter = null;
try
{
while (reader.IsStartElement())
{
if (reader.IsStartElement(Atom10Constants.NameTag, Atom10Constants.Atom10Namespace))
{
result.Name = reader.ReadElementString();
}
else if (reader.IsStartElement(Atom10Constants.UriTag, Atom10Constants.Atom10Namespace))
{
result.Uri = reader.ReadElementString();
}
else if (reader.IsStartElement(Atom10Constants.EmailTag, Atom10Constants.Atom10Namespace))
{
result.Email = reader.ReadElementString();
}
else
{
if (!TryParseElement(reader, result, this.Version))
{
if (this.preserveElementExtensions)
{
CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, this.maxExtensionSize);
}
else
{
TraceSyndicationElementIgnoredOnRead(reader);
reader.Skip();
}
}
}
}
LoadElementExtensions(buffer, extWriter, result);
}
finally
{
if (extWriter != null)
{
((IDisposable) extWriter).Dispose();
}
}
reader.ReadEndElement();
}
}
TextSyndicationContent ReadTextContentFrom(XmlReader reader, string context)
{
return ReadTextContentFrom(reader, context, this.PreserveAttributeExtensions);
}
void WriteCategoriesTo(XmlWriter writer, Collection<SyndicationCategory> categories)
{
for (int i = 0; i < categories.Count; ++i)
{
WriteCategory(writer, categories[i], this.Version);
}
}
void WriteFeed(XmlWriter writer)
{
if (this.Feed == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.FeedFormatterDoesNotHaveFeed)));
}
WriteFeedTo(writer, this.Feed, false); // isSourceFeed
}
void WriteFeedTo(XmlWriter writer, SyndicationFeed feed, bool isSourceFeed)
{
if (!isSourceFeed)
{
if (!string.IsNullOrEmpty(feed.Language))
{
writer.WriteAttributeString("xml", "lang", XmlNs, feed.Language);
}
if (feed.BaseUri != null)
{
writer.WriteAttributeString("xml", "base", XmlNs, FeedUtils.GetUriString(feed.BaseUri));
}
WriteAttributeExtensions(writer, feed, this.Version);
}
bool isElementRequired = !isSourceFeed;
TextSyndicationContent title = feed.Title;
if (isElementRequired)
{
title = title ?? new TextSyndicationContent(string.Empty);
}
WriteContentTo(writer, Atom10Constants.TitleTag, title);
WriteContentTo(writer, Atom10Constants.SubtitleTag, feed.Description);
string id = feed.Id;
if (isElementRequired)
{
id = id ?? idGenerator.Next();
}
WriteElement(writer, Atom10Constants.IdTag, id);
WriteContentTo(writer, Atom10Constants.RightsTag, feed.Copyright);
WriteFeedLastUpdatedTimeTo(writer, feed.LastUpdatedTime, isElementRequired);
WriteCategoriesTo(writer, feed.Categories);
if (feed.ImageUrl != null)
{
WriteElement(writer, Atom10Constants.LogoTag, feed.ImageUrl.ToString());
}
WriteFeedAuthorsTo(writer, feed.Authors);
WriteFeedContributorsTo(writer, feed.Contributors);
WriteElement(writer, Atom10Constants.GeneratorTag, feed.Generator);
for (int i = 0; i < feed.Links.Count; ++i)
{
WriteLink(writer, feed.Links[i], feed.BaseUri);
}
WriteElementExtensions(writer, feed, this.Version);
if (!isSourceFeed)
{
WriteItems(writer, feed.Items, feed.BaseUri);
}
}
void WriteItemContents(XmlWriter dictWriter, SyndicationItem item, Uri feedBaseUri)
{
Uri baseUriToWrite = FeedUtils.GetBaseUriToWrite(feedBaseUri, item.BaseUri);
if (baseUriToWrite != null)
{
dictWriter.WriteAttributeString("xml", "base", XmlNs, FeedUtils.GetUriString(baseUriToWrite));
}
WriteAttributeExtensions(dictWriter, item, this.Version);
string id = item.Id ?? idGenerator.Next();
WriteElement(dictWriter, Atom10Constants.IdTag, id);
TextSyndicationContent title = item.Title ?? new TextSyndicationContent(string.Empty);
WriteContentTo(dictWriter, Atom10Constants.TitleTag, title);
WriteContentTo(dictWriter, Atom10Constants.SummaryTag, item.Summary);
if (item.PublishDate != DateTimeOffset.MinValue)
{
dictWriter.WriteElementString(Atom10Constants.PublishedTag,
Atom10Constants.Atom10Namespace,
AsString(item.PublishDate));
}
WriteItemLastUpdatedTimeTo(dictWriter, item.LastUpdatedTime);
WriteItemAuthorsTo(dictWriter, item.Authors);
WriteItemContributorsTo(dictWriter, item.Contributors);
for (int i = 0; i < item.Links.Count; ++i)
{
WriteLink(dictWriter, item.Links[i], item.BaseUri);
}
WriteCategoriesTo(dictWriter, item.Categories);
WriteContentTo(dictWriter, Atom10Constants.ContentTag, item.Content);
WriteContentTo(dictWriter, Atom10Constants.RightsTag, item.Copyright);
if (item.SourceFeed != null)
{
dictWriter.WriteStartElement(Atom10Constants.SourceFeedTag, Atom10Constants.Atom10Namespace);
WriteFeedTo(dictWriter, item.SourceFeed, true); // isSourceFeed
dictWriter.WriteEndElement();
}
WriteElementExtensions(dictWriter, item, this.Version);
}
void WritePersonTo(XmlWriter writer, SyndicationPerson p, string elementName)
{
writer.WriteStartElement(elementName, Atom10Constants.Atom10Namespace);
WriteAttributeExtensions(writer, p, this.Version);
WriteElement(writer, Atom10Constants.NameTag, p.Name);
if (!string.IsNullOrEmpty(p.Uri))
{
writer.WriteElementString(Atom10Constants.UriTag, Atom10Constants.Atom10Namespace, p.Uri);
}
if (!string.IsNullOrEmpty(p.Email))
{
writer.WriteElementString(Atom10Constants.EmailTag, Atom10Constants.Atom10Namespace, p.Email);
}
WriteElementExtensions(writer, p, this.Version);
writer.WriteEndElement();
}
}
[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 ()
{
// constructors
public Atom10FeedFormatter()
: base(typeof(TSyndicationFeed))
{
}
public Atom10FeedFormatter(TSyndicationFeed feedToWrite)
: base(feedToWrite)
{
}
protected override SyndicationFeed CreateFeedInstance()
{
return new TSyndicationFeed();
}
}
}