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

608 lines
23 KiB
C#

//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.ServiceModel.Syndication
{
using System;
using System.Diagnostics;
using System.Globalization;
using System.Runtime;
using System.Runtime.Serialization;
using System.ServiceModel.Diagnostics;
using System.Xml;
using DiagnosticUtility = System.ServiceModel.DiagnosticUtility;
using System.Runtime.CompilerServices;
[TypeForwardedFrom("System.ServiceModel.Web, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
[DataContract]
public abstract class SyndicationFeedFormatter
{
SyndicationFeed feed;
protected SyndicationFeedFormatter()
{
this.feed = null;
}
protected SyndicationFeedFormatter(SyndicationFeed feedToWrite)
{
if (feedToWrite == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("feedToWrite");
}
this.feed = feedToWrite;
}
public SyndicationFeed Feed
{
get
{
return this.feed;
}
}
public abstract string Version
{ get; }
public abstract bool CanRead(XmlReader reader);
public abstract void ReadFrom(XmlReader reader);
public override string ToString()
{
return String.Format(CultureInfo.CurrentCulture, "{0}, SyndicationVersion={1}", this.GetType(), this.Version);
}
public abstract void WriteTo(XmlWriter writer);
internal static protected SyndicationCategory CreateCategory(SyndicationFeed feed)
{
if (feed == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("feed");
}
return GetNonNullValue<SyndicationCategory>(feed.CreateCategory(), SR.FeedCreatedNullCategory);
}
internal static protected SyndicationCategory CreateCategory(SyndicationItem item)
{
if (item == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item");
}
return GetNonNullValue<SyndicationCategory>(item.CreateCategory(), SR.ItemCreatedNullCategory);
}
internal static protected SyndicationItem CreateItem(SyndicationFeed feed)
{
if (feed == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("feed");
}
return GetNonNullValue<SyndicationItem>(feed.CreateItem(), SR.FeedCreatedNullItem);
}
internal static protected SyndicationLink CreateLink(SyndicationFeed feed)
{
if (feed == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("feed");
}
return GetNonNullValue<SyndicationLink>(feed.CreateLink(), SR.FeedCreatedNullPerson);
}
internal static protected SyndicationLink CreateLink(SyndicationItem item)
{
if (item == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item");
}
return GetNonNullValue<SyndicationLink>(item.CreateLink(), SR.ItemCreatedNullPerson);
}
internal static protected SyndicationPerson CreatePerson(SyndicationFeed feed)
{
if (feed == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("feed");
}
return GetNonNullValue<SyndicationPerson>(feed.CreatePerson(), SR.FeedCreatedNullPerson);
}
internal static protected SyndicationPerson CreatePerson(SyndicationItem item)
{
if (item == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item");
}
return GetNonNullValue<SyndicationPerson>(item.CreatePerson(), SR.ItemCreatedNullPerson);
}
internal static protected void LoadElementExtensions(XmlReader reader, SyndicationFeed feed, int maxExtensionSize)
{
if (feed == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("feed");
}
feed.LoadElementExtensions(reader, maxExtensionSize);
}
internal static protected void LoadElementExtensions(XmlReader reader, SyndicationItem item, int maxExtensionSize)
{
if (item == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item");
}
item.LoadElementExtensions(reader, maxExtensionSize);
}
internal static protected void LoadElementExtensions(XmlReader reader, SyndicationCategory category, int maxExtensionSize)
{
if (category == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("category");
}
category.LoadElementExtensions(reader, maxExtensionSize);
}
internal static protected void LoadElementExtensions(XmlReader reader, SyndicationLink link, int maxExtensionSize)
{
if (link == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("link");
}
link.LoadElementExtensions(reader, maxExtensionSize);
}
internal static protected void LoadElementExtensions(XmlReader reader, SyndicationPerson person, int maxExtensionSize)
{
if (person == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("person");
}
person.LoadElementExtensions(reader, maxExtensionSize);
}
internal static protected bool TryParseAttribute(string name, string ns, string value, SyndicationFeed feed, string version)
{
if (feed == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("feed");
}
if (FeedUtils.IsXmlns(name, ns))
{
return true;
}
return feed.TryParseAttribute(name, ns, value, version);
}
internal static protected bool TryParseAttribute(string name, string ns, string value, SyndicationItem item, string version)
{
if (item == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item");
}
if (FeedUtils.IsXmlns(name, ns))
{
return true;
}
return item.TryParseAttribute(name, ns, value, version);
}
internal static protected bool TryParseAttribute(string name, string ns, string value, SyndicationCategory category, string version)
{
if (category == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("category");
}
if (FeedUtils.IsXmlns(name, ns))
{
return true;
}
return category.TryParseAttribute(name, ns, value, version);
}
internal static protected bool TryParseAttribute(string name, string ns, string value, SyndicationLink link, string version)
{
if (link == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("link");
}
if (FeedUtils.IsXmlns(name, ns))
{
return true;
}
return link.TryParseAttribute(name, ns, value, version);
}
internal static protected bool TryParseAttribute(string name, string ns, string value, SyndicationPerson person, string version)
{
if (person == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("person");
}
if (FeedUtils.IsXmlns(name, ns))
{
return true;
}
return person.TryParseAttribute(name, ns, value, version);
}
internal static protected bool TryParseContent(XmlReader reader, SyndicationItem item, string contentType, string version, out SyndicationContent content)
{
return item.TryParseContent(reader, contentType, version, out content);
}
internal static protected bool TryParseElement(XmlReader reader, SyndicationFeed feed, string version)
{
if (feed == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("feed");
}
return feed.TryParseElement(reader, version);
}
internal static protected bool TryParseElement(XmlReader reader, SyndicationItem item, string version)
{
if (item == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item");
}
return item.TryParseElement(reader, version);
}
internal static protected bool TryParseElement(XmlReader reader, SyndicationCategory category, string version)
{
if (category == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("category");
}
return category.TryParseElement(reader, version);
}
internal static protected bool TryParseElement(XmlReader reader, SyndicationLink link, string version)
{
if (link == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("link");
}
return link.TryParseElement(reader, version);
}
internal static protected bool TryParseElement(XmlReader reader, SyndicationPerson person, string version)
{
if (person == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("person");
}
return person.TryParseElement(reader, version);
}
internal static protected void WriteAttributeExtensions(XmlWriter writer, SyndicationFeed feed, string version)
{
if (feed == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("feed");
}
feed.WriteAttributeExtensions(writer, version);
}
internal static protected void WriteAttributeExtensions(XmlWriter writer, SyndicationItem item, string version)
{
if (item == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item");
}
item.WriteAttributeExtensions(writer, version);
}
internal static protected void WriteAttributeExtensions(XmlWriter writer, SyndicationCategory category, string version)
{
if (category == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("category");
}
category.WriteAttributeExtensions(writer, version);
}
internal static protected void WriteAttributeExtensions(XmlWriter writer, SyndicationLink link, string version)
{
if (link == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("link");
}
link.WriteAttributeExtensions(writer, version);
}
internal static protected void WriteAttributeExtensions(XmlWriter writer, SyndicationPerson person, string version)
{
if (person == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("person");
}
person.WriteAttributeExtensions(writer, version);
}
internal static protected void WriteElementExtensions(XmlWriter writer, SyndicationFeed feed, string version)
{
if (feed == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("feed");
}
feed.WriteElementExtensions(writer, version);
}
internal static protected void WriteElementExtensions(XmlWriter writer, SyndicationItem item, string version)
{
if (item == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item");
}
item.WriteElementExtensions(writer, version);
}
internal static protected void WriteElementExtensions(XmlWriter writer, SyndicationCategory category, string version)
{
if (category == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("category");
}
category.WriteElementExtensions(writer, version);
}
internal static protected void WriteElementExtensions(XmlWriter writer, SyndicationLink link, string version)
{
if (link == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("link");
}
link.WriteElementExtensions(writer, version);
}
internal static protected void WriteElementExtensions(XmlWriter writer, SyndicationPerson person, string version)
{
if (person == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("person");
}
person.WriteElementExtensions(writer, version);
}
internal protected virtual void SetFeed(SyndicationFeed feed)
{
if (feed == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("feed");
}
this.feed = feed;
}
internal static void CloseBuffer(XmlBuffer buffer, XmlDictionaryWriter extWriter)
{
if (buffer == null)
{
return;
}
extWriter.WriteEndElement();
buffer.CloseSection();
buffer.Close();
}
internal static void CreateBufferIfRequiredAndWriteNode(ref XmlBuffer buffer, ref XmlDictionaryWriter extWriter, XmlReader reader, int maxExtensionSize)
{
if (buffer == null)
{
buffer = new XmlBuffer(maxExtensionSize);
extWriter = buffer.OpenSection(XmlDictionaryReaderQuotas.Max);
extWriter.WriteStartElement(Rss20Constants.ExtensionWrapperTag);
}
extWriter.WriteNode(reader, false);
}
internal static SyndicationFeed CreateFeedInstance(Type feedType)
{
if (feedType.Equals(typeof(SyndicationFeed)))
{
return new SyndicationFeed();
}
else
{
return (SyndicationFeed) Activator.CreateInstance(feedType);
}
}
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, SyndicationFeed feed)
{
if (feed == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("feed");
}
CloseBuffer(buffer, writer);
feed.LoadElementExtensions(buffer);
}
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, SyndicationItem item)
{
if (item == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("item");
}
CloseBuffer(buffer, writer);
item.LoadElementExtensions(buffer);
}
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, SyndicationCategory category)
{
if (category == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("category");
}
CloseBuffer(buffer, writer);
category.LoadElementExtensions(buffer);
}
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, SyndicationLink link)
{
if (link == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("link");
}
CloseBuffer(buffer, writer);
link.LoadElementExtensions(buffer);
}
internal static void LoadElementExtensions(XmlBuffer buffer, XmlDictionaryWriter writer, SyndicationPerson person)
{
if (person == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("person");
}
CloseBuffer(buffer, writer);
person.LoadElementExtensions(buffer);
}
internal static void MoveToStartElement(XmlReader reader)
{
Fx.Assert(reader != null, "reader != null");
if (!reader.IsStartElement())
{
XmlExceptionHelper.ThrowStartElementExpected(XmlDictionaryReader.CreateDictionaryReader(reader));
}
}
internal static void TraceFeedReadBegin()
{
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.SyndicationReadFeedBegin, SR.GetString(SR.TraceCodeSyndicationFeedReadBegin));
}
}
internal static void TraceFeedReadEnd()
{
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.SyndicationReadFeedEnd, SR.GetString(SR.TraceCodeSyndicationFeedReadEnd));
}
}
internal static void TraceFeedWriteBegin()
{
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.SyndicationWriteFeedBegin, SR.GetString(SR.TraceCodeSyndicationFeedWriteBegin));
}
}
internal static void TraceFeedWriteEnd()
{
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.SyndicationWriteFeedEnd, SR.GetString(SR.TraceCodeSyndicationFeedWriteEnd));
}
}
internal static void TraceItemReadBegin()
{
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.SyndicationReadItemBegin, SR.GetString(SR.TraceCodeSyndicationItemReadBegin));
}
}
internal static void TraceItemReadEnd()
{
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.SyndicationReadItemEnd, SR.GetString(SR.TraceCodeSyndicationItemReadEnd));
}
}
internal static void TraceItemWriteBegin()
{
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.SyndicationWriteItemBegin, SR.GetString(SR.TraceCodeSyndicationItemWriteBegin));
}
}
internal static void TraceItemWriteEnd()
{
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.SyndicationWriteItemEnd, SR.GetString(SR.TraceCodeSyndicationItemWriteEnd));
}
}
internal static void TraceSyndicationElementIgnoredOnRead(XmlReader reader)
{
if (DiagnosticUtility.ShouldTraceInformation)
{
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.SyndicationProtocolElementIgnoredOnRead, SR.GetString(SR.TraceCodeSyndicationProtocolElementIgnoredOnRead, reader.NodeType, reader.LocalName, reader.NamespaceURI));
}
}
protected abstract SyndicationFeed CreateFeedInstance();
static T GetNonNullValue<T>(T value, string errorMsg)
{
if (value == null)
{
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(errorMsg)));
}
return value;
}
static class XmlExceptionHelper
{
static void ThrowXmlException(XmlDictionaryReader reader, string res, string arg1)
{
string s = SR.GetString(res, arg1);
IXmlLineInfo lineInfo = reader as IXmlLineInfo;
if (lineInfo != null && lineInfo.HasLineInfo())
{
s += " " + SR.GetString(SR.XmlLineInfo, lineInfo.LineNumber, lineInfo.LinePosition);
}
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(s));
}
static string GetName(string prefix, string localName)
{
if (prefix.Length == 0)
return localName;
else
return string.Concat(prefix, ":", localName);
}
static string GetWhatWasFound(XmlDictionaryReader reader)
{
if (reader.EOF)
return SR.GetString(SR.XmlFoundEndOfFile);
switch (reader.NodeType)
{
case XmlNodeType.Element:
return SR.GetString(SR.XmlFoundElement, GetName(reader.Prefix, reader.LocalName), reader.NamespaceURI);
case XmlNodeType.EndElement:
return SR.GetString(SR.XmlFoundEndElement, GetName(reader.Prefix, reader.LocalName), reader.NamespaceURI);
case XmlNodeType.Text:
case XmlNodeType.Whitespace:
case XmlNodeType.SignificantWhitespace:
return SR.GetString(SR.XmlFoundText, reader.Value);
case XmlNodeType.Comment:
return SR.GetString(SR.XmlFoundComment, reader.Value);
case XmlNodeType.CDATA:
return SR.GetString(SR.XmlFoundCData, reader.Value);
}
return SR.GetString(SR.XmlFoundNodeType, reader.NodeType);
}
static public void ThrowStartElementExpected(XmlDictionaryReader reader)
{
ThrowXmlException(reader, SR.XmlStartElementExpected, GetWhatWasFound(reader));
}
}
}
}