878 lines
31 KiB
C#
878 lines
31 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Xml;
|
|
using SerializationException = System.Runtime.Serialization.SerializationException;
|
|
|
|
namespace Compat.Runtime.Serialization
|
|
{
|
|
internal class ExtensionDataReader : XmlReader
|
|
{
|
|
private enum ExtensionDataNodeType
|
|
{
|
|
None,
|
|
Element,
|
|
EndElement,
|
|
Text,
|
|
Xml,
|
|
ReferencedElement,
|
|
NullElement,
|
|
}
|
|
|
|
private readonly Hashtable cache = new Hashtable();
|
|
private ElementData[] elements;
|
|
private ElementData element;
|
|
private ElementData nextElement;
|
|
private ReadState readState = ReadState.Initial;
|
|
private ExtensionDataNodeType internalNodeType;
|
|
private XmlNodeType nodeType;
|
|
private int depth;
|
|
private string localName;
|
|
private string ns;
|
|
private string prefix;
|
|
private string value;
|
|
private int attributeCount;
|
|
private int attributeIndex;
|
|
private XmlNodeReader xmlNodeReader;
|
|
private Queue<IDataNode> deserializedDataNodes;
|
|
private readonly XmlObjectSerializerReadContext context;
|
|
|
|
private static readonly Dictionary<string, string> nsToPrefixTable;
|
|
|
|
private static readonly Dictionary<string, string> prefixToNsTable;
|
|
|
|
static ExtensionDataReader()
|
|
{
|
|
nsToPrefixTable = new Dictionary<string, string>();
|
|
prefixToNsTable = new Dictionary<string, string>();
|
|
AddPrefix(Globals.XsiPrefix, Globals.SchemaInstanceNamespace);
|
|
AddPrefix(Globals.SerPrefix, Globals.SerializationNamespace);
|
|
AddPrefix(string.Empty, string.Empty);
|
|
}
|
|
|
|
internal ExtensionDataReader(XmlObjectSerializerReadContext context)
|
|
{
|
|
attributeIndex = -1;
|
|
this.context = context;
|
|
}
|
|
|
|
internal void SetDeserializedValue(object obj)
|
|
{
|
|
IDataNode deserializedDataNode = (deserializedDataNodes == null || deserializedDataNodes.Count == 0) ? null : deserializedDataNodes.Dequeue();
|
|
if (deserializedDataNode != null && !(obj is IDataNode))
|
|
{
|
|
deserializedDataNode.Value = obj;
|
|
deserializedDataNode.IsFinalValue = true;
|
|
}
|
|
}
|
|
|
|
internal IDataNode GetCurrentNode()
|
|
{
|
|
IDataNode retVal = element.dataNode;
|
|
Skip();
|
|
return retVal;
|
|
}
|
|
|
|
internal void SetDataNode(IDataNode dataNode, string name, string ns)
|
|
{
|
|
SetNextElement(dataNode, name, ns, null);
|
|
element = nextElement;
|
|
nextElement = null;
|
|
SetElement();
|
|
}
|
|
|
|
internal void Reset()
|
|
{
|
|
localName = null;
|
|
ns = null;
|
|
prefix = null;
|
|
value = null;
|
|
attributeCount = 0;
|
|
attributeIndex = -1;
|
|
depth = 0;
|
|
element = null;
|
|
nextElement = null;
|
|
elements = null;
|
|
deserializedDataNodes = null;
|
|
}
|
|
|
|
private bool IsXmlDataNode => (internalNodeType == ExtensionDataNodeType.Xml);
|
|
|
|
public override XmlNodeType NodeType => IsXmlDataNode ? xmlNodeReader.NodeType : nodeType;
|
|
public override string LocalName => IsXmlDataNode ? xmlNodeReader.LocalName : localName;
|
|
public override string NamespaceURI => IsXmlDataNode ? xmlNodeReader.NamespaceURI : ns;
|
|
public override string Prefix => IsXmlDataNode ? xmlNodeReader.Prefix : prefix;
|
|
public override string Value => IsXmlDataNode ? xmlNodeReader.Value : value;
|
|
public override int Depth => IsXmlDataNode ? xmlNodeReader.Depth : depth;
|
|
public override int AttributeCount => IsXmlDataNode ? xmlNodeReader.AttributeCount : attributeCount;
|
|
public override bool EOF => IsXmlDataNode ? xmlNodeReader.EOF : (readState == ReadState.EndOfFile);
|
|
public override ReadState ReadState => IsXmlDataNode ? xmlNodeReader.ReadState : readState;
|
|
public override bool IsEmptyElement => IsXmlDataNode ? xmlNodeReader.IsEmptyElement : false;
|
|
public override bool IsDefault => IsXmlDataNode ? xmlNodeReader.IsDefault : base.IsDefault;
|
|
public override char QuoteChar => IsXmlDataNode ? xmlNodeReader.QuoteChar : base.QuoteChar;
|
|
public override XmlSpace XmlSpace => IsXmlDataNode ? xmlNodeReader.XmlSpace : base.XmlSpace;
|
|
public override string XmlLang => IsXmlDataNode ? xmlNodeReader.XmlLang : base.XmlLang;
|
|
public override string this[int i] => IsXmlDataNode ? xmlNodeReader[i] : GetAttribute(i);
|
|
public override string this[string name] => IsXmlDataNode ? xmlNodeReader[name] : GetAttribute(name);
|
|
public override string this[string name, string namespaceURI] => IsXmlDataNode ? xmlNodeReader[name, namespaceURI] : GetAttribute(name, namespaceURI);
|
|
|
|
public override bool MoveToFirstAttribute()
|
|
{
|
|
if (IsXmlDataNode)
|
|
{
|
|
return xmlNodeReader.MoveToFirstAttribute();
|
|
}
|
|
|
|
if (attributeCount == 0)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
MoveToAttribute(0);
|
|
return true;
|
|
}
|
|
|
|
public override bool MoveToNextAttribute()
|
|
{
|
|
if (IsXmlDataNode)
|
|
{
|
|
return xmlNodeReader.MoveToNextAttribute();
|
|
}
|
|
|
|
if (attributeIndex + 1 >= attributeCount)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
MoveToAttribute(attributeIndex + 1);
|
|
return true;
|
|
}
|
|
|
|
public override void MoveToAttribute(int index)
|
|
{
|
|
if (IsXmlDataNode)
|
|
{
|
|
xmlNodeReader.MoveToAttribute(index);
|
|
}
|
|
else
|
|
{
|
|
if (index < 0 || index >= attributeCount)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.InvalidXmlDeserializingExtensionData));
|
|
}
|
|
|
|
nodeType = XmlNodeType.Attribute;
|
|
AttributeData attribute = element.attributes[index];
|
|
localName = attribute.localName;
|
|
ns = attribute.ns;
|
|
prefix = attribute.prefix;
|
|
value = attribute.value;
|
|
attributeIndex = index;
|
|
}
|
|
}
|
|
|
|
public override string GetAttribute(string name, string namespaceURI)
|
|
{
|
|
if (IsXmlDataNode)
|
|
{
|
|
return xmlNodeReader.GetAttribute(name, namespaceURI);
|
|
}
|
|
|
|
for (int i = 0; i < element.attributeCount; i++)
|
|
{
|
|
AttributeData attribute = element.attributes[i];
|
|
if (attribute.localName == name && attribute.ns == namespaceURI)
|
|
{
|
|
return attribute.value;
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public override bool MoveToAttribute(string name, string namespaceURI)
|
|
{
|
|
if (IsXmlDataNode)
|
|
{
|
|
return xmlNodeReader.MoveToAttribute(name, ns);
|
|
}
|
|
|
|
for (int i = 0; i < element.attributeCount; i++)
|
|
{
|
|
AttributeData attribute = element.attributes[i];
|
|
if (attribute.localName == name && attribute.ns == namespaceURI)
|
|
{
|
|
MoveToAttribute(i);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public override bool MoveToElement()
|
|
{
|
|
if (IsXmlDataNode)
|
|
{
|
|
return xmlNodeReader.MoveToElement();
|
|
}
|
|
|
|
if (nodeType != XmlNodeType.Attribute)
|
|
{
|
|
return false;
|
|
}
|
|
|
|
SetElement();
|
|
return true;
|
|
}
|
|
|
|
private void SetElement()
|
|
{
|
|
nodeType = XmlNodeType.Element;
|
|
localName = element.localName;
|
|
ns = element.ns;
|
|
prefix = element.prefix;
|
|
value = string.Empty;
|
|
attributeCount = element.attributeCount;
|
|
attributeIndex = -1;
|
|
}
|
|
|
|
public override string LookupNamespace(string prefix)
|
|
{
|
|
if (IsXmlDataNode)
|
|
{
|
|
return xmlNodeReader.LookupNamespace(prefix);
|
|
}
|
|
|
|
if (!prefixToNsTable.TryGetValue(prefix, out string ns))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
return ns;
|
|
}
|
|
|
|
public override void Skip()
|
|
{
|
|
if (IsXmlDataNode)
|
|
{
|
|
xmlNodeReader.Skip();
|
|
}
|
|
else
|
|
{
|
|
if (ReadState != ReadState.Interactive)
|
|
{
|
|
return;
|
|
}
|
|
|
|
MoveToElement();
|
|
if (IsElementNode(internalNodeType))
|
|
{
|
|
int depth = 1;
|
|
while (depth != 0)
|
|
{
|
|
if (!Read())
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.InvalidXmlDeserializingExtensionData));
|
|
}
|
|
|
|
if (IsElementNode(internalNodeType))
|
|
{
|
|
depth++;
|
|
}
|
|
else if (internalNodeType == ExtensionDataNodeType.EndElement)
|
|
{
|
|
ReadEndElement();
|
|
depth--;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Read();
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool IsElementNode(ExtensionDataNodeType nodeType)
|
|
{
|
|
return (nodeType == ExtensionDataNodeType.Element ||
|
|
nodeType == ExtensionDataNodeType.ReferencedElement ||
|
|
nodeType == ExtensionDataNodeType.NullElement);
|
|
}
|
|
|
|
public override void Close()
|
|
{
|
|
if (IsXmlDataNode)
|
|
{
|
|
xmlNodeReader.Close();
|
|
}
|
|
else
|
|
{
|
|
Reset();
|
|
readState = ReadState.Closed;
|
|
}
|
|
}
|
|
|
|
public override bool Read()
|
|
{
|
|
if (nodeType == XmlNodeType.Attribute && MoveToNextAttribute())
|
|
{
|
|
return true;
|
|
}
|
|
|
|
MoveNext(element.dataNode);
|
|
|
|
switch (internalNodeType)
|
|
{
|
|
case ExtensionDataNodeType.Element:
|
|
case ExtensionDataNodeType.ReferencedElement:
|
|
case ExtensionDataNodeType.NullElement:
|
|
PushElement();
|
|
SetElement();
|
|
break;
|
|
|
|
case ExtensionDataNodeType.Text:
|
|
nodeType = XmlNodeType.Text;
|
|
prefix = string.Empty;
|
|
ns = string.Empty;
|
|
localName = string.Empty;
|
|
attributeCount = 0;
|
|
attributeIndex = -1;
|
|
break;
|
|
|
|
case ExtensionDataNodeType.EndElement:
|
|
nodeType = XmlNodeType.EndElement;
|
|
prefix = string.Empty;
|
|
ns = string.Empty;
|
|
localName = string.Empty;
|
|
value = string.Empty;
|
|
attributeCount = 0;
|
|
attributeIndex = -1;
|
|
PopElement();
|
|
break;
|
|
|
|
case ExtensionDataNodeType.None:
|
|
if (depth != 0)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.InvalidXmlDeserializingExtensionData));
|
|
}
|
|
|
|
nodeType = XmlNodeType.None;
|
|
prefix = string.Empty;
|
|
ns = string.Empty;
|
|
localName = string.Empty;
|
|
value = string.Empty;
|
|
attributeCount = 0;
|
|
readState = ReadState.EndOfFile;
|
|
return false;
|
|
|
|
case ExtensionDataNodeType.Xml:
|
|
// do nothing
|
|
break;
|
|
|
|
default:
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.InvalidStateInExtensionDataReader));
|
|
}
|
|
readState = ReadState.Interactive;
|
|
return true;
|
|
}
|
|
|
|
public override string Name
|
|
{
|
|
get
|
|
{
|
|
if (IsXmlDataNode)
|
|
{
|
|
return xmlNodeReader.Name;
|
|
}
|
|
Fx.Assert("ExtensionDataReader Name property should only be called for IXmlSerializable");
|
|
return string.Empty;
|
|
}
|
|
}
|
|
|
|
public override bool HasValue
|
|
{
|
|
get
|
|
{
|
|
if (IsXmlDataNode)
|
|
{
|
|
return xmlNodeReader.HasValue;
|
|
}
|
|
Fx.Assert("ExtensionDataReader HasValue property should only be called for IXmlSerializable");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public override string BaseURI
|
|
{
|
|
get
|
|
{
|
|
if (IsXmlDataNode)
|
|
{
|
|
return xmlNodeReader.BaseURI;
|
|
}
|
|
Fx.Assert("ExtensionDataReader BaseURI property should only be called for IXmlSerializable");
|
|
return string.Empty;
|
|
}
|
|
}
|
|
|
|
public override XmlNameTable NameTable
|
|
{
|
|
get
|
|
{
|
|
if (IsXmlDataNode)
|
|
{
|
|
return xmlNodeReader.NameTable;
|
|
}
|
|
Fx.Assert("ExtensionDataReader NameTable property should only be called for IXmlSerializable");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public override string GetAttribute(string name)
|
|
{
|
|
if (IsXmlDataNode)
|
|
{
|
|
return xmlNodeReader.GetAttribute(name);
|
|
}
|
|
Fx.Assert("ExtensionDataReader GetAttribute method should only be called for IXmlSerializable");
|
|
return null;
|
|
}
|
|
|
|
public override string GetAttribute(int i)
|
|
{
|
|
if (IsXmlDataNode)
|
|
{
|
|
return xmlNodeReader.GetAttribute(i);
|
|
}
|
|
Fx.Assert("ExtensionDataReader GetAttribute method should only be called for IXmlSerializable");
|
|
return null;
|
|
}
|
|
|
|
public override bool MoveToAttribute(string name)
|
|
{
|
|
if (IsXmlDataNode)
|
|
{
|
|
return xmlNodeReader.MoveToAttribute(name);
|
|
}
|
|
Fx.Assert("ExtensionDataReader MoveToAttribute method should only be called for IXmlSerializable");
|
|
return false;
|
|
}
|
|
|
|
public override void ResolveEntity()
|
|
{
|
|
if (IsXmlDataNode)
|
|
{
|
|
xmlNodeReader.ResolveEntity();
|
|
}
|
|
else
|
|
{
|
|
Fx.Assert("ExtensionDataReader ResolveEntity method should only be called for IXmlSerializable");
|
|
}
|
|
}
|
|
|
|
public override bool ReadAttributeValue()
|
|
{
|
|
if (IsXmlDataNode)
|
|
{
|
|
return xmlNodeReader.ReadAttributeValue();
|
|
}
|
|
Fx.Assert("ExtensionDataReader ReadAttributeValue method should only be called for IXmlSerializable");
|
|
return false;
|
|
}
|
|
|
|
private void MoveNext(IDataNode dataNode)
|
|
{
|
|
switch (internalNodeType)
|
|
{
|
|
case ExtensionDataNodeType.Text:
|
|
case ExtensionDataNodeType.ReferencedElement:
|
|
case ExtensionDataNodeType.NullElement:
|
|
internalNodeType = ExtensionDataNodeType.EndElement;
|
|
return;
|
|
default:
|
|
Type dataNodeType = dataNode.DataType;
|
|
if (dataNodeType == Globals.TypeOfClassDataNode)
|
|
{
|
|
MoveNextInClass((ClassDataNode)dataNode);
|
|
}
|
|
else if (dataNodeType == Globals.TypeOfCollectionDataNode)
|
|
{
|
|
MoveNextInCollection((CollectionDataNode)dataNode);
|
|
}
|
|
else if (dataNodeType == Globals.TypeOfISerializableDataNode)
|
|
{
|
|
MoveNextInISerializable((ISerializableDataNode)dataNode);
|
|
}
|
|
else if (dataNodeType == Globals.TypeOfXmlDataNode)
|
|
{
|
|
MoveNextInXml((XmlDataNode)dataNode);
|
|
}
|
|
else if (dataNode.Value != null)
|
|
{
|
|
MoveToDeserializedObject(dataNode);
|
|
}
|
|
else
|
|
{
|
|
Fx.Assert("Encountered invalid data node when deserializing unknown data");
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(SR.InvalidStateInExtensionDataReader));
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
private void SetNextElement(IDataNode node, string name, string ns, string prefix)
|
|
{
|
|
internalNodeType = ExtensionDataNodeType.Element;
|
|
nextElement = GetNextElement();
|
|
nextElement.localName = name;
|
|
nextElement.ns = ns;
|
|
nextElement.prefix = prefix;
|
|
if (node == null)
|
|
{
|
|
nextElement.attributeCount = 0;
|
|
nextElement.AddAttribute(Globals.XsiPrefix, Globals.SchemaInstanceNamespace, Globals.XsiNilLocalName, Globals.True);
|
|
internalNodeType = ExtensionDataNodeType.NullElement;
|
|
}
|
|
else if (!CheckIfNodeHandled(node))
|
|
{
|
|
AddDeserializedDataNode(node);
|
|
node.GetData(nextElement);
|
|
if (node is XmlDataNode)
|
|
{
|
|
MoveNextInXml((XmlDataNode)node);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void AddDeserializedDataNode(IDataNode node)
|
|
{
|
|
if (node.Id != Globals.NewObjectId && (node.Value == null || !node.IsFinalValue))
|
|
{
|
|
if (deserializedDataNodes == null)
|
|
{
|
|
deserializedDataNodes = new Queue<IDataNode>();
|
|
}
|
|
|
|
deserializedDataNodes.Enqueue(node);
|
|
}
|
|
}
|
|
|
|
private bool CheckIfNodeHandled(IDataNode node)
|
|
{
|
|
bool handled = false;
|
|
if (node.Id != Globals.NewObjectId)
|
|
{
|
|
handled = (cache[node] != null);
|
|
if (handled)
|
|
{
|
|
if (nextElement == null)
|
|
{
|
|
nextElement = GetNextElement();
|
|
}
|
|
|
|
nextElement.attributeCount = 0;
|
|
nextElement.AddAttribute(Globals.SerPrefix, Globals.SerializationNamespace, Globals.RefLocalName, node.Id.ToString(NumberFormatInfo.InvariantInfo));
|
|
nextElement.AddAttribute(Globals.XsiPrefix, Globals.SchemaInstanceNamespace, Globals.XsiNilLocalName, Globals.True);
|
|
internalNodeType = ExtensionDataNodeType.ReferencedElement;
|
|
}
|
|
else
|
|
{
|
|
cache.Add(node, node);
|
|
}
|
|
}
|
|
return handled;
|
|
}
|
|
|
|
private void MoveNextInClass(ClassDataNode dataNode)
|
|
{
|
|
if (dataNode.Members != null && element.childElementIndex < dataNode.Members.Count)
|
|
{
|
|
if (element.childElementIndex == 0)
|
|
{
|
|
context.IncrementItemCount(-dataNode.Members.Count);
|
|
}
|
|
|
|
ExtensionDataMember member = dataNode.Members[element.childElementIndex++];
|
|
SetNextElement(member.Value, member.Name, member.Namespace, GetPrefix(member.Namespace));
|
|
}
|
|
else
|
|
{
|
|
internalNodeType = ExtensionDataNodeType.EndElement;
|
|
element.childElementIndex = 0;
|
|
}
|
|
}
|
|
|
|
private void MoveNextInCollection(CollectionDataNode dataNode)
|
|
{
|
|
if (dataNode.Items != null && element.childElementIndex < dataNode.Items.Count)
|
|
{
|
|
if (element.childElementIndex == 0)
|
|
{
|
|
context.IncrementItemCount(-dataNode.Items.Count);
|
|
}
|
|
|
|
IDataNode item = dataNode.Items[element.childElementIndex++];
|
|
SetNextElement(item, dataNode.ItemName, dataNode.ItemNamespace, GetPrefix(dataNode.ItemNamespace));
|
|
}
|
|
else
|
|
{
|
|
internalNodeType = ExtensionDataNodeType.EndElement;
|
|
element.childElementIndex = 0;
|
|
}
|
|
}
|
|
|
|
private void MoveNextInISerializable(ISerializableDataNode dataNode)
|
|
{
|
|
if (dataNode.Members != null && element.childElementIndex < dataNode.Members.Count)
|
|
{
|
|
if (element.childElementIndex == 0)
|
|
{
|
|
context.IncrementItemCount(-dataNode.Members.Count);
|
|
}
|
|
|
|
ISerializableDataMember member = dataNode.Members[element.childElementIndex++];
|
|
SetNextElement(member.Value, member.Name, string.Empty, string.Empty);
|
|
}
|
|
else
|
|
{
|
|
internalNodeType = ExtensionDataNodeType.EndElement;
|
|
element.childElementIndex = 0;
|
|
}
|
|
}
|
|
|
|
private void MoveNextInXml(XmlDataNode dataNode)
|
|
{
|
|
if (IsXmlDataNode)
|
|
{
|
|
xmlNodeReader.Read();
|
|
if (xmlNodeReader.Depth == 0)
|
|
{
|
|
internalNodeType = ExtensionDataNodeType.EndElement;
|
|
xmlNodeReader = null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
internalNodeType = ExtensionDataNodeType.Xml;
|
|
if (element == null)
|
|
{
|
|
element = nextElement;
|
|
}
|
|
else
|
|
{
|
|
PushElement();
|
|
}
|
|
|
|
XmlNode wrapperElement = XmlObjectSerializerReadContext.CreateWrapperXmlElement(dataNode.OwnerDocument,
|
|
dataNode.XmlAttributes, dataNode.XmlChildNodes, element.prefix, element.localName, element.ns);
|
|
for (int i = 0; i < element.attributeCount; i++)
|
|
{
|
|
AttributeData a = element.attributes[i];
|
|
XmlAttribute xmlAttr = dataNode.OwnerDocument.CreateAttribute(a.prefix, a.localName, a.ns);
|
|
xmlAttr.Value = a.value;
|
|
wrapperElement.Attributes.Append(xmlAttr);
|
|
}
|
|
xmlNodeReader = new XmlNodeReader(wrapperElement);
|
|
xmlNodeReader.Read();
|
|
}
|
|
}
|
|
|
|
private void MoveToDeserializedObject(IDataNode dataNode)
|
|
{
|
|
Type type = dataNode.DataType;
|
|
bool isTypedNode = true;
|
|
if (type == Globals.TypeOfObject)
|
|
{
|
|
type = dataNode.Value.GetType();
|
|
if (type == Globals.TypeOfObject)
|
|
{
|
|
internalNodeType = ExtensionDataNodeType.EndElement;
|
|
return;
|
|
}
|
|
isTypedNode = false;
|
|
}
|
|
|
|
if (!MoveToText(type, dataNode, isTypedNode))
|
|
{
|
|
if (dataNode.IsFinalValue)
|
|
{
|
|
internalNodeType = ExtensionDataNodeType.EndElement;
|
|
}
|
|
else
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.Format(SR.InvalidDataNode, DataContract.GetClrTypeFullName(type))));
|
|
}
|
|
}
|
|
}
|
|
|
|
private bool MoveToText(Type type, IDataNode dataNode, bool isTypedNode)
|
|
{
|
|
bool handled = true;
|
|
switch (Type.GetTypeCode(type))
|
|
{
|
|
case TypeCode.Boolean:
|
|
value = XmlConvert.ToString(isTypedNode ? ((DataNode<bool>)dataNode).GetValue() : (bool)dataNode.Value);
|
|
break;
|
|
case TypeCode.Char:
|
|
value = XmlConvert.ToString((int)(isTypedNode ? ((DataNode<char>)dataNode).GetValue() : (char)dataNode.Value));
|
|
break;
|
|
case TypeCode.Byte:
|
|
value = XmlConvert.ToString(isTypedNode ? ((DataNode<byte>)dataNode).GetValue() : (byte)dataNode.Value);
|
|
break;
|
|
case TypeCode.Int16:
|
|
value = XmlConvert.ToString(isTypedNode ? ((DataNode<short>)dataNode).GetValue() : (short)dataNode.Value);
|
|
break;
|
|
case TypeCode.Int32:
|
|
value = XmlConvert.ToString(isTypedNode ? ((DataNode<int>)dataNode).GetValue() : (int)dataNode.Value);
|
|
break;
|
|
case TypeCode.Int64:
|
|
value = XmlConvert.ToString(isTypedNode ? ((DataNode<long>)dataNode).GetValue() : (long)dataNode.Value);
|
|
break;
|
|
case TypeCode.Single:
|
|
value = XmlConvert.ToString(isTypedNode ? ((DataNode<float>)dataNode).GetValue() : (float)dataNode.Value);
|
|
break;
|
|
case TypeCode.Double:
|
|
value = XmlConvert.ToString(isTypedNode ? ((DataNode<double>)dataNode).GetValue() : (double)dataNode.Value);
|
|
break;
|
|
case TypeCode.Decimal:
|
|
value = XmlConvert.ToString(isTypedNode ? ((DataNode<decimal>)dataNode).GetValue() : (decimal)dataNode.Value);
|
|
break;
|
|
case TypeCode.DateTime:
|
|
DateTime dateTime = isTypedNode ? ((DataNode<DateTime>)dataNode).GetValue() : (DateTime)dataNode.Value;
|
|
value = dateTime.ToString("yyyy-MM-ddTHH:mm:ss.fffffffK", DateTimeFormatInfo.InvariantInfo);
|
|
break;
|
|
case TypeCode.String:
|
|
value = isTypedNode ? ((DataNode<string>)dataNode).GetValue() : (string)dataNode.Value;
|
|
break;
|
|
case TypeCode.SByte:
|
|
value = XmlConvert.ToString(isTypedNode ? ((DataNode<sbyte>)dataNode).GetValue() : (sbyte)dataNode.Value);
|
|
break;
|
|
case TypeCode.UInt16:
|
|
value = XmlConvert.ToString(isTypedNode ? ((DataNode<ushort>)dataNode).GetValue() : (ushort)dataNode.Value);
|
|
break;
|
|
case TypeCode.UInt32:
|
|
value = XmlConvert.ToString(isTypedNode ? ((DataNode<uint>)dataNode).GetValue() : (uint)dataNode.Value);
|
|
break;
|
|
case TypeCode.UInt64:
|
|
value = XmlConvert.ToString(isTypedNode ? ((DataNode<ulong>)dataNode).GetValue() : (ulong)dataNode.Value);
|
|
break;
|
|
case TypeCode.Object:
|
|
default:
|
|
if (type == Globals.TypeOfByteArray)
|
|
{
|
|
byte[] bytes = isTypedNode ? ((DataNode<byte[]>)dataNode).GetValue() : (byte[])dataNode.Value;
|
|
value = (bytes == null) ? string.Empty : Convert.ToBase64String(bytes);
|
|
}
|
|
else if (type == Globals.TypeOfTimeSpan)
|
|
{
|
|
value = XmlConvert.ToString(isTypedNode ? ((DataNode<TimeSpan>)dataNode).GetValue() : (TimeSpan)dataNode.Value);
|
|
}
|
|
else if (type == Globals.TypeOfGuid)
|
|
{
|
|
Guid guid = isTypedNode ? ((DataNode<Guid>)dataNode).GetValue() : (Guid)dataNode.Value;
|
|
value = guid.ToString();
|
|
}
|
|
else if (type == Globals.TypeOfUri)
|
|
{
|
|
Uri uri = isTypedNode ? ((DataNode<Uri>)dataNode).GetValue() : (Uri)dataNode.Value;
|
|
value = uri.GetComponents(UriComponents.SerializationInfoString, UriFormat.UriEscaped);
|
|
}
|
|
else
|
|
{
|
|
handled = false;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
if (handled)
|
|
{
|
|
internalNodeType = ExtensionDataNodeType.Text;
|
|
}
|
|
|
|
return handled;
|
|
}
|
|
|
|
private void PushElement()
|
|
{
|
|
GrowElementsIfNeeded();
|
|
elements[depth++] = element;
|
|
if (nextElement == null)
|
|
{
|
|
element = GetNextElement();
|
|
}
|
|
else
|
|
{
|
|
element = nextElement;
|
|
nextElement = null;
|
|
}
|
|
}
|
|
|
|
private void PopElement()
|
|
{
|
|
prefix = element.prefix;
|
|
localName = element.localName;
|
|
ns = element.ns;
|
|
|
|
if (depth == 0)
|
|
{
|
|
return;
|
|
}
|
|
|
|
depth--;
|
|
|
|
if (elements != null)
|
|
{
|
|
element = elements[depth];
|
|
}
|
|
}
|
|
|
|
private void GrowElementsIfNeeded()
|
|
{
|
|
if (elements == null)
|
|
{
|
|
elements = new ElementData[8];
|
|
}
|
|
else if (elements.Length == depth)
|
|
{
|
|
ElementData[] newElements = new ElementData[elements.Length * 2];
|
|
Array.Copy(elements, 0, newElements, 0, elements.Length);
|
|
elements = newElements;
|
|
}
|
|
}
|
|
|
|
private ElementData GetNextElement()
|
|
{
|
|
int nextDepth = depth + 1;
|
|
return (elements == null || elements.Length <= nextDepth || elements[nextDepth] == null)
|
|
? new ElementData() : elements[nextDepth];
|
|
}
|
|
|
|
internal static string GetPrefix(string ns)
|
|
{
|
|
ns = ns ?? string.Empty;
|
|
if (!nsToPrefixTable.TryGetValue(ns, out string prefix))
|
|
{
|
|
lock (nsToPrefixTable)
|
|
{
|
|
if (!nsToPrefixTable.TryGetValue(ns, out prefix))
|
|
{
|
|
prefix = (ns == null || ns.Length == 0) ? string.Empty : "p" + nsToPrefixTable.Count;
|
|
AddPrefix(prefix, ns);
|
|
}
|
|
}
|
|
}
|
|
return prefix;
|
|
}
|
|
|
|
private static void AddPrefix(string prefix, string ns)
|
|
{
|
|
nsToPrefixTable.Add(ns, prefix);
|
|
prefixToNsTable.Add(prefix, ns);
|
|
}
|
|
}
|
|
}
|