Example #1
0
        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);
                    _nextElement.AddAttribute(Globals.XsiPrefix, Globals.SchemaInstanceNamespace, Globals.XsiNilLocalName, Globals.True);
                    _internalNodeType = ExtensionDataNodeType.ReferencedElement;
                }
                else
                {
                    _cache.Add(node, node);
                }
            }
            return(handled);
        }
Example #2
0
        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);
                    this.internalNodeType = ExtensionDataNodeType.ReferencedElement;
                }
                else
                {
                    cache.Add(node, node);
                }
            }
            return(handled);
        }
 private void MoveNextInXml(XmlDataNode dataNode)
 {
     if (this.IsXmlDataNode)
     {
         this.xmlNodeReader.Read();
         if (this.xmlNodeReader.Depth == 0)
         {
             this.internalNodeType = ExtensionDataNodeType.EndElement;
             this.xmlNodeReader    = null;
         }
     }
     else
     {
         this.internalNodeType = ExtensionDataNodeType.Xml;
         if (this.element == null)
         {
             this.element = this.nextElement;
         }
         else
         {
             this.PushElement();
         }
         System.Xml.XmlNode node = XmlObjectSerializerReadContext.CreateWrapperXmlElement(dataNode.OwnerDocument, dataNode.XmlAttributes, dataNode.XmlChildNodes, this.element.prefix, this.element.localName, this.element.ns);
         for (int i = 0; i < this.element.attributeCount; i++)
         {
             AttributeData           data      = this.element.attributes[i];
             System.Xml.XmlAttribute attribute = dataNode.OwnerDocument.CreateAttribute(data.prefix, data.localName, data.ns);
             attribute.Value = data.value;
             node.Attributes.Append(attribute);
         }
         this.xmlNodeReader = new XmlNodeReader(node);
         this.xmlNodeReader.Read();
     }
 }
Example #4
0
        void MoveToDeserializedObject(IDataNode dataNode)
        {
            Type type        = dataNode.DataType;
            bool isTypedNode = true;

            if (type == Globals.TypeOfObject)
            {
                type = dataNode.Value.GetType();
                if (type == Globals.TypeOfObject)
                {
                    this.internalNodeType = ExtensionDataNodeType.EndElement;
                    return;
                }
                isTypedNode = false;
            }

            if (!MoveToText(type, dataNode, isTypedNode))
            {
                if (dataNode.IsFinalValue)
                {
                    this.internalNodeType = ExtensionDataNodeType.EndElement;
                }
                else
                {
                    throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.InvalidDataNode, DataContract.GetClrTypeFullName(type))));
                }
            }
        }
Example #5
0
        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 new XmlException(SR.Format(SR.InvalidDataNode, DataContract.GetClrTypeFullName(type)));
                }
            }
        }
 private bool IsElementNode(ExtensionDataNodeType nodeType)
 {
     if ((nodeType != ExtensionDataNodeType.Element) && (nodeType != ExtensionDataNodeType.ReferencedElement))
     {
         return(nodeType == ExtensionDataNodeType.NullElement);
     }
     return(true);
 }
 private void MoveNextInISerializable(ISerializableDataNode dataNode)
 {
     if ((dataNode.Members != null) && (this.element.childElementIndex < dataNode.Members.Count))
     {
         if (this.element.childElementIndex == 0)
         {
             this.context.IncrementItemCount(-dataNode.Members.Count);
         }
         ISerializableDataMember member = dataNode.Members[this.element.childElementIndex++];
         this.SetNextElement(member.Value, member.Name, string.Empty, string.Empty);
     }
     else
     {
         this.internalNodeType          = ExtensionDataNodeType.EndElement;
         this.element.childElementIndex = 0;
     }
 }
 private void MoveNextInCollection(CollectionDataNode dataNode)
 {
     if ((dataNode.Items != null) && (this.element.childElementIndex < dataNode.Items.Count))
     {
         if (this.element.childElementIndex == 0)
         {
             this.context.IncrementItemCount(-dataNode.Items.Count);
         }
         IDataNode node = dataNode.Items[this.element.childElementIndex++];
         this.SetNextElement(node, dataNode.ItemName, dataNode.ItemNamespace, GetPrefix(dataNode.ItemNamespace));
     }
     else
     {
         this.internalNodeType          = ExtensionDataNodeType.EndElement;
         this.element.childElementIndex = 0;
     }
 }
 private void MoveNextInClass(ClassDataNode dataNode)
 {
     if ((dataNode.Members != null) && (this.element.childElementIndex < dataNode.Members.Count))
     {
         if (this.element.childElementIndex == 0)
         {
             this.context.IncrementItemCount(-dataNode.Members.Count);
         }
         ExtensionDataMember member = dataNode.Members[this.element.childElementIndex++];
         this.SetNextElement(member.Value, member.Name, member.Namespace, GetPrefix(member.Namespace));
     }
     else
     {
         this.internalNodeType          = ExtensionDataNodeType.EndElement;
         this.element.childElementIndex = 0;
     }
 }
Example #10
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;
            }
        }
Example #11
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;
            }
        }
Example #12
0
        void MoveNext(IDataNode dataNode)
        {
            switch (this.internalNodeType)
            {
            case ExtensionDataNodeType.Text:
            case ExtensionDataNodeType.ReferencedElement:
            case ExtensionDataNodeType.NullElement:
                this.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.GetString(SR.InvalidStateInExtensionDataReader)));
                }
                break;
            }
        }
 private bool CheckIfNodeHandled(IDataNode node)
 {
     bool flag = false;
     if (node.Id != Globals.NewObjectId)
     {
         flag = this.cache[node] != null;
         if (flag)
         {
             if (this.nextElement == null)
             {
                 this.nextElement = this.GetNextElement();
             }
             this.nextElement.attributeCount = 0;
             this.nextElement.AddAttribute("z", "http://schemas.microsoft.com/2003/10/Serialization/", "Ref", node.Id.ToString(NumberFormatInfo.InvariantInfo));
             this.nextElement.AddAttribute("i", "http://www.w3.org/2001/XMLSchema-instance", "nil", "true");
             this.internalNodeType = ExtensionDataNodeType.ReferencedElement;
             return flag;
         }
         this.cache.Add(node, node);
     }
     return flag;
 }
Example #14
0
 void SetNextElement(IDataNode node, string name, string ns, string prefix)
 {
     this.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);
         this.internalNodeType = ExtensionDataNodeType.NullElement;
     }
     else if (!CheckIfNodeHandled(node))
     {
         AddDeserializedDataNode(node);
         node.GetData(nextElement);
         if (node is XmlDataNode)
         {
             MoveNextInXml((XmlDataNode)node);
         }
     }
 }
        private bool CheckIfNodeHandled(IDataNode node)
        {
            bool flag = false;

            if (node.Id != Globals.NewObjectId)
            {
                flag = this.cache[node] != null;
                if (flag)
                {
                    if (this.nextElement == null)
                    {
                        this.nextElement = this.GetNextElement();
                    }
                    this.nextElement.attributeCount = 0;
                    this.nextElement.AddAttribute("z", "http://schemas.microsoft.com/2003/10/Serialization/", "Ref", node.Id.ToString(NumberFormatInfo.InvariantInfo));
                    this.nextElement.AddAttribute("i", "http://www.w3.org/2001/XMLSchema-instance", "nil", "true");
                    this.internalNodeType = ExtensionDataNodeType.ReferencedElement;
                    return(flag);
                }
                this.cache.Add(node, node);
            }
            return(flag);
        }
 private void SetNextElement(IDataNode node, string name, string ns, string prefix)
 {
     this.internalNodeType      = ExtensionDataNodeType.Element;
     this.nextElement           = this.GetNextElement();
     this.nextElement.localName = name;
     this.nextElement.ns        = ns;
     this.nextElement.prefix    = prefix;
     if (node == null)
     {
         this.nextElement.attributeCount = 0;
         this.nextElement.AddAttribute("i", "http://www.w3.org/2001/XMLSchema-instance", "nil", "true");
         this.internalNodeType = ExtensionDataNodeType.NullElement;
     }
     else if (!this.CheckIfNodeHandled(node))
     {
         this.AddDeserializedDataNode(node);
         node.GetData(this.nextElement);
         if (node is XmlDataNode)
         {
             this.MoveNextInXml((XmlDataNode)node);
         }
     }
 }
        private void MoveNext(IDataNode dataNode)
        {
            switch (this.internalNodeType)
            {
            case ExtensionDataNodeType.Text:
            case ExtensionDataNodeType.ReferencedElement:
            case ExtensionDataNodeType.NullElement:
                this.internalNodeType = ExtensionDataNodeType.EndElement;
                return;
            }
            Type dataType = dataNode.DataType;

            if (dataType == Globals.TypeOfClassDataNode)
            {
                this.MoveNextInClass((ClassDataNode)dataNode);
            }
            else if (dataType == Globals.TypeOfCollectionDataNode)
            {
                this.MoveNextInCollection((CollectionDataNode)dataNode);
            }
            else if (dataType == Globals.TypeOfISerializableDataNode)
            {
                this.MoveNextInISerializable((ISerializableDataNode)dataNode);
            }
            else if (dataType == Globals.TypeOfXmlDataNode)
            {
                this.MoveNextInXml((XmlDataNode)dataNode);
            }
            else
            {
                if (dataNode.Value == null)
                {
                    throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(System.Runtime.Serialization.SR.GetString("InvalidStateInExtensionDataReader")));
                }
                this.MoveToDeserializedObject(dataNode);
            }
        }
Example #18
0
        void MoveNextInXml(XmlDataNode dataNode)
        {
            if (IsXmlDataNode)
            {
                xmlNodeReader.Read();
                if (xmlNodeReader.Depth == 0)
                {
                    this.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 bool MoveToText(Type type, IDataNode dataNode, bool isTypedNode)
        {
            bool flag = true;

            switch (Type.GetTypeCode(type))
            {
            case TypeCode.Boolean:
                this.value = XmlConvert.ToString(isTypedNode ? ((DataNode <bool>)dataNode).GetValue() : ((bool)dataNode.Value));
                break;

            case TypeCode.Char:
                this.value = XmlConvert.ToString(isTypedNode ? ((int)((DataNode <char>)dataNode).GetValue()) : ((char)dataNode.Value));
                break;

            case TypeCode.SByte:
                this.value = XmlConvert.ToString(isTypedNode ? ((DataNode <sbyte>)dataNode).GetValue() : ((sbyte)dataNode.Value));
                break;

            case TypeCode.Byte:
                this.value = XmlConvert.ToString(isTypedNode ? ((DataNode <byte>)dataNode).GetValue() : ((byte)dataNode.Value));
                break;

            case TypeCode.Int16:
                this.value = XmlConvert.ToString(isTypedNode ? ((DataNode <short>)dataNode).GetValue() : ((short)dataNode.Value));
                break;

            case TypeCode.UInt16:
                this.value = XmlConvert.ToString(isTypedNode ? ((DataNode <ushort>)dataNode).GetValue() : ((ushort)dataNode.Value));
                break;

            case TypeCode.Int32:
                this.value = XmlConvert.ToString(isTypedNode ? ((DataNode <int>)dataNode).GetValue() : ((int)dataNode.Value));
                break;

            case TypeCode.UInt32:
                this.value = XmlConvert.ToString(isTypedNode ? ((DataNode <uint>)dataNode).GetValue() : ((uint)dataNode.Value));
                break;

            case TypeCode.Int64:
                this.value = XmlConvert.ToString(isTypedNode ? ((DataNode <long>)dataNode).GetValue() : ((long)dataNode.Value));
                break;

            case TypeCode.UInt64:
                this.value = XmlConvert.ToString(isTypedNode ? ((DataNode <ulong>)dataNode).GetValue() : ((ulong)dataNode.Value));
                break;

            case TypeCode.Single:
                this.value = XmlConvert.ToString(isTypedNode ? ((DataNode <float>)dataNode).GetValue() : ((float)dataNode.Value));
                break;

            case TypeCode.Double:
                this.value = XmlConvert.ToString(isTypedNode ? ((DataNode <double>)dataNode).GetValue() : ((double)dataNode.Value));
                break;

            case TypeCode.Decimal:
                this.value = XmlConvert.ToString(isTypedNode ? ((DataNode <decimal>)dataNode).GetValue() : ((decimal)dataNode.Value));
                break;

            case TypeCode.DateTime:
                this.value = (isTypedNode ? ((DataNode <DateTime>)dataNode).GetValue() : ((DateTime)dataNode.Value)).ToString("yyyy-MM-ddTHH:mm:ss.fffffffK", DateTimeFormatInfo.InvariantInfo);
                break;

            case TypeCode.String:
                this.value = isTypedNode ? ((DataNode <string>)dataNode).GetValue() : ((string)dataNode.Value);
                break;

            default:
                if (type == Globals.TypeOfByteArray)
                {
                    byte[] inArray = isTypedNode ? ((DataNode <byte[]>)dataNode).GetValue() : ((byte[])dataNode.Value);
                    this.value = (inArray == null) ? string.Empty : Convert.ToBase64String(inArray);
                }
                else if (type == Globals.TypeOfTimeSpan)
                {
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode <TimeSpan>)dataNode).GetValue() : ((TimeSpan)dataNode.Value));
                }
                else if (type == Globals.TypeOfGuid)
                {
                    this.value = (isTypedNode ? ((DataNode <Guid>)dataNode).GetValue() : ((Guid)dataNode.Value)).ToString();
                }
                else if (type == Globals.TypeOfUri)
                {
                    this.value = (isTypedNode ? ((DataNode <Uri>)dataNode).GetValue() : ((Uri)dataNode.Value)).GetComponents(UriComponents.SerializationInfoString, UriFormat.UriEscaped);
                }
                else
                {
                    flag = false;
                }
                break;
            }
            if (flag)
            {
                this.internalNodeType = ExtensionDataNodeType.Text;
            }
            return(flag);
        }
Example #20
0
        private bool MoveToText(Type type, IDataNode dataNode, bool isTypedNode)
        {
            bool handled = true;

            switch (type.GetTypeCode())
            {
            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 SetNextElement(IDataNode node, string name, string ns, string prefix)
 {
     this.internalNodeType = ExtensionDataNodeType.Element;
     this.nextElement = this.GetNextElement();
     this.nextElement.localName = name;
     this.nextElement.ns = ns;
     this.nextElement.prefix = prefix;
     if (node == null)
     {
         this.nextElement.attributeCount = 0;
         this.nextElement.AddAttribute("i", "http://www.w3.org/2001/XMLSchema-instance", "nil", "true");
         this.internalNodeType = ExtensionDataNodeType.NullElement;
     }
     else if (!this.CheckIfNodeHandled(node))
     {
         this.AddDeserializedDataNode(node);
         node.GetData(this.nextElement);
         if (node is XmlDataNode)
         {
             this.MoveNextInXml((XmlDataNode) node);
         }
     }
 }
Example #22
0
        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 new XmlException(SR.Format(SR.InvalidDataNode, DataContract.GetClrTypeFullName(type)));
                }
            }
        }
        private bool MoveToText(Type type, IDataNode dataNode, bool isTypedNode)
        {
            bool flag = true;
            switch (Type.GetTypeCode(type))
            {
                case TypeCode.Boolean:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<bool>) dataNode).GetValue() : ((bool) dataNode.Value));
                    break;

                case TypeCode.Char:
                    this.value = XmlConvert.ToString(isTypedNode ? ((int) ((DataNode<char>) dataNode).GetValue()) : ((char) dataNode.Value));
                    break;

                case TypeCode.SByte:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<sbyte>) dataNode).GetValue() : ((sbyte) dataNode.Value));
                    break;

                case TypeCode.Byte:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<byte>) dataNode).GetValue() : ((byte) dataNode.Value));
                    break;

                case TypeCode.Int16:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<short>) dataNode).GetValue() : ((short) dataNode.Value));
                    break;

                case TypeCode.UInt16:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<ushort>) dataNode).GetValue() : ((ushort) dataNode.Value));
                    break;

                case TypeCode.Int32:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<int>) dataNode).GetValue() : ((int) dataNode.Value));
                    break;

                case TypeCode.UInt32:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<uint>) dataNode).GetValue() : ((uint) dataNode.Value));
                    break;

                case TypeCode.Int64:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<long>) dataNode).GetValue() : ((long) dataNode.Value));
                    break;

                case TypeCode.UInt64:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<ulong>) dataNode).GetValue() : ((ulong) dataNode.Value));
                    break;

                case TypeCode.Single:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<float>) dataNode).GetValue() : ((float) dataNode.Value));
                    break;

                case TypeCode.Double:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<double>) dataNode).GetValue() : ((double) dataNode.Value));
                    break;

                case TypeCode.Decimal:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<decimal>) dataNode).GetValue() : ((decimal) dataNode.Value));
                    break;

                case TypeCode.DateTime:
                    this.value = (isTypedNode ? ((DataNode<DateTime>) dataNode).GetValue() : ((DateTime) dataNode.Value)).ToString("yyyy-MM-ddTHH:mm:ss.fffffffK", DateTimeFormatInfo.InvariantInfo);
                    break;

                case TypeCode.String:
                    this.value = isTypedNode ? ((DataNode<string>) dataNode).GetValue() : ((string) dataNode.Value);
                    break;

                default:
                    if (type == Globals.TypeOfByteArray)
                    {
                        byte[] inArray = isTypedNode ? ((DataNode<byte[]>) dataNode).GetValue() : ((byte[]) dataNode.Value);
                        this.value = (inArray == null) ? string.Empty : Convert.ToBase64String(inArray);
                    }
                    else if (type == Globals.TypeOfTimeSpan)
                    {
                        this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<TimeSpan>) dataNode).GetValue() : ((TimeSpan) dataNode.Value));
                    }
                    else if (type == Globals.TypeOfGuid)
                    {
                        this.value = (isTypedNode ? ((DataNode<Guid>) dataNode).GetValue() : ((Guid) dataNode.Value)).ToString();
                    }
                    else if (type == Globals.TypeOfUri)
                    {
                        this.value = (isTypedNode ? ((DataNode<Uri>) dataNode).GetValue() : ((Uri) dataNode.Value)).GetComponents(UriComponents.SerializationInfoString, UriFormat.UriEscaped);
                    }
                    else
                    {
                        flag = false;
                    }
                    break;
            }
            if (flag)
            {
                this.internalNodeType = ExtensionDataNodeType.Text;
            }
            return flag;
        }
        bool MoveToText(Type type, IDataNode dataNode, bool isTypedNode)
        {
            bool handled = true;
            switch (Type.GetTypeCode(type))
            {
                case TypeCode.Boolean:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<bool>)dataNode).GetValue() : (bool)dataNode.Value);
                    break;
                case TypeCode.Char:
                    this.value = XmlConvert.ToString((int)(isTypedNode ? ((DataNode<char>)dataNode).GetValue() : (char)dataNode.Value));
                    break;
                case TypeCode.Byte:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<byte>)dataNode).GetValue() : (byte)dataNode.Value);
                    break;
                case TypeCode.Int16:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<short>)dataNode).GetValue() : (short)dataNode.Value);
                    break;
                case TypeCode.Int32:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<int>)dataNode).GetValue() : (int)dataNode.Value);
                    break;
                case TypeCode.Int64:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<long>)dataNode).GetValue() : (long)dataNode.Value);
                    break;
                case TypeCode.Single:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<float>)dataNode).GetValue() : (float)dataNode.Value);
                    break;
                case TypeCode.Double:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<double>)dataNode).GetValue() : (double)dataNode.Value);
                    break;
                case TypeCode.Decimal:
                    this.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;
                    this.value = dateTime.ToString("yyyy-MM-ddTHH:mm:ss.fffffffK", DateTimeFormatInfo.InvariantInfo);
                    break;
                case TypeCode.String:
                    this.value = isTypedNode ? ((DataNode<string>)dataNode).GetValue() : (string)dataNode.Value;
                    break;
                case TypeCode.SByte:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<sbyte>)dataNode).GetValue() : (sbyte)dataNode.Value);
                    break;
                case TypeCode.UInt16:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<ushort>)dataNode).GetValue() : (ushort)dataNode.Value);
                    break;
                case TypeCode.UInt32:
                    this.value = XmlConvert.ToString(isTypedNode ? ((DataNode<uint>)dataNode).GetValue() : (uint)dataNode.Value);
                    break;
                case TypeCode.UInt64:
                    this.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;
                        this.value = (bytes == null) ? String.Empty : Convert.ToBase64String(bytes);
                    }
                    else if (type == Globals.TypeOfTimeSpan)
                        this.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;
                        this.value = guid.ToString();
                    }
                    else if (type == Globals.TypeOfUri)
                    {
                        Uri uri = isTypedNode ? ((DataNode<Uri>)dataNode).GetValue() : (Uri)dataNode.Value;
                        this.value = uri.GetComponents(UriComponents.SerializationInfoString, UriFormat.UriEscaped);
                    }
                    else
                        handled = false;
                    break;
            }

            if (handled)
                this.internalNodeType = ExtensionDataNodeType.Text;
            return handled;
        }
        void MoveNextInXml(XmlDataNode dataNode)
        {
            if (IsXmlDataNode)
            {
                xmlNodeReader.Read();
                if (xmlNodeReader.Depth == 0)
                {
                    this.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();
            }
        }
        void MoveNextInCollection(CollectionDataNode dataNode)
        {
            if (dataNode.Items != null && element.childElementIndex < dataNode.Items.Count)
            {
                if (element.childElementIndex == 0)
                    this.context.IncrementItemCount(-dataNode.Items.Count);

                IDataNode item = dataNode.Items[element.childElementIndex++];
                SetNextElement(item, dataNode.ItemName, dataNode.ItemNamespace, GetPrefix(dataNode.ItemNamespace));
            }
            else
            {
                this.internalNodeType = ExtensionDataNodeType.EndElement;
                element.childElementIndex = 0;
            }
        }
 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);
             this.internalNodeType = ExtensionDataNodeType.ReferencedElement;
         }
         else
         {
             cache.Add(node, node);
         }
     }
     return handled;
 }
 void MoveNext(IDataNode dataNode)
 {
     switch (this.internalNodeType)
     {
         case ExtensionDataNodeType.Text:
         case ExtensionDataNodeType.ReferencedElement:
         case ExtensionDataNodeType.NullElement:
             this.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.GetString(SR.InvalidStateInExtensionDataReader)));
             }
             break;
     }
 }
 bool IsElementNode(ExtensionDataNodeType nodeType)
 {
     return (nodeType == ExtensionDataNodeType.Element ||
         nodeType == ExtensionDataNodeType.ReferencedElement ||
         nodeType == ExtensionDataNodeType.NullElement);
 }
 private bool IsElementNode(ExtensionDataNodeType nodeType)
 {
     if ((nodeType != ExtensionDataNodeType.Element) && (nodeType != ExtensionDataNodeType.ReferencedElement))
     {
         return (nodeType == ExtensionDataNodeType.NullElement);
     }
     return true;
 }
 void SetNextElement(IDataNode node, string name, string ns, string prefix)
 {
     this.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);
         this.internalNodeType = ExtensionDataNodeType.NullElement;
     }
     else if (!CheckIfNodeHandled(node))
     {
         AddDeserializedDataNode(node);
         node.GetData(nextElement);
         if (node is XmlDataNode)
             MoveNextInXml((XmlDataNode)node);
     }
 }
 private void MoveNext(IDataNode dataNode)
 {
     switch (this.internalNodeType)
     {
         case ExtensionDataNodeType.Text:
         case ExtensionDataNodeType.ReferencedElement:
         case ExtensionDataNodeType.NullElement:
             this.internalNodeType = ExtensionDataNodeType.EndElement;
             return;
     }
     Type dataType = dataNode.DataType;
     if (dataType == Globals.TypeOfClassDataNode)
     {
         this.MoveNextInClass((ClassDataNode) dataNode);
     }
     else if (dataType == Globals.TypeOfCollectionDataNode)
     {
         this.MoveNextInCollection((CollectionDataNode) dataNode);
     }
     else if (dataType == Globals.TypeOfISerializableDataNode)
     {
         this.MoveNextInISerializable((ISerializableDataNode) dataNode);
     }
     else if (dataType == Globals.TypeOfXmlDataNode)
     {
         this.MoveNextInXml((XmlDataNode) dataNode);
     }
     else
     {
         if (dataNode.Value == null)
         {
             throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new SerializationException(System.Runtime.Serialization.SR.GetString("InvalidStateInExtensionDataReader")));
         }
         this.MoveToDeserializedObject(dataNode);
     }
 }
        void MoveNextInClass(ClassDataNode dataNode)
        {
            if (dataNode.Members != null && element.childElementIndex < dataNode.Members.Count)
            {
                if (element.childElementIndex == 0)
                    this.context.IncrementItemCount(-dataNode.Members.Count);

                ExtensionDataMember member = dataNode.Members[element.childElementIndex++];
                SetNextElement(member.Value, member.Name, member.Namespace, GetPrefix(member.Namespace));
            }
            else
            {
                this.internalNodeType = ExtensionDataNodeType.EndElement;
                element.childElementIndex = 0;
            }
        }
 private void MoveNextInCollection(CollectionDataNode dataNode)
 {
     if ((dataNode.Items != null) && (this.element.childElementIndex < dataNode.Items.Count))
     {
         if (this.element.childElementIndex == 0)
         {
             this.context.IncrementItemCount(-dataNode.Items.Count);
         }
         IDataNode node = dataNode.Items[this.element.childElementIndex++];
         this.SetNextElement(node, dataNode.ItemName, dataNode.ItemNamespace, GetPrefix(dataNode.ItemNamespace));
     }
     else
     {
         this.internalNodeType = ExtensionDataNodeType.EndElement;
         this.element.childElementIndex = 0;
     }
 }
        void MoveNextInISerializable(ISerializableDataNode dataNode)
        {
            if (dataNode.Members != null && element.childElementIndex < dataNode.Members.Count)
            {
                if (element.childElementIndex == 0)
                    this.context.IncrementItemCount(-dataNode.Members.Count);

                ISerializableDataMember member = dataNode.Members[element.childElementIndex++];
                SetNextElement(member.Value, member.Name, String.Empty, String.Empty);
            }
            else
            {
                this.internalNodeType = ExtensionDataNodeType.EndElement;
                element.childElementIndex = 0;
            }
        }
 private void MoveNextInISerializable(ISerializableDataNode dataNode)
 {
     if ((dataNode.Members != null) && (this.element.childElementIndex < dataNode.Members.Count))
     {
         if (this.element.childElementIndex == 0)
         {
             this.context.IncrementItemCount(-dataNode.Members.Count);
         }
         ISerializableDataMember member = dataNode.Members[this.element.childElementIndex++];
         this.SetNextElement(member.Value, member.Name, string.Empty, string.Empty);
     }
     else
     {
         this.internalNodeType = ExtensionDataNodeType.EndElement;
         this.element.childElementIndex = 0;
     }
 }
        void MoveToDeserializedObject(IDataNode dataNode)
        {
            Type type = dataNode.DataType;
            bool isTypedNode = true;
            if (type == Globals.TypeOfObject)
            {
                type = dataNode.Value.GetType();
                if (type == Globals.TypeOfObject)
                {
                    this.internalNodeType = ExtensionDataNodeType.EndElement;
                    return;
                }
                isTypedNode = false;
            }

            if (!MoveToText(type, dataNode, isTypedNode))
            {
                if (dataNode.IsFinalValue)
                {
                    this.internalNodeType = ExtensionDataNodeType.EndElement;
                }
                else
                {
                    throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.InvalidDataNode, DataContract.GetClrTypeFullName(type))));
                }
            }
        }
 private void MoveNextInXml(XmlDataNode dataNode)
 {
     if (this.IsXmlDataNode)
     {
         this.xmlNodeReader.Read();
         if (this.xmlNodeReader.Depth == 0)
         {
             this.internalNodeType = ExtensionDataNodeType.EndElement;
             this.xmlNodeReader = null;
         }
     }
     else
     {
         this.internalNodeType = ExtensionDataNodeType.Xml;
         if (this.element == null)
         {
             this.element = this.nextElement;
         }
         else
         {
             this.PushElement();
         }
         System.Xml.XmlNode node = XmlObjectSerializerReadContext.CreateWrapperXmlElement(dataNode.OwnerDocument, dataNode.XmlAttributes, dataNode.XmlChildNodes, this.element.prefix, this.element.localName, this.element.ns);
         for (int i = 0; i < this.element.attributeCount; i++)
         {
             AttributeData data = this.element.attributes[i];
             System.Xml.XmlAttribute attribute = dataNode.OwnerDocument.CreateAttribute(data.prefix, data.localName, data.ns);
             attribute.Value = data.value;
             node.Attributes.Append(attribute);
         }
         this.xmlNodeReader = new XmlNodeReader(node);
         this.xmlNodeReader.Read();
     }
 }
Example #39
0
 private bool IsElementNode(ExtensionDataNodeType nodeType)
 {
     return(nodeType == ExtensionDataNodeType.Element ||
            nodeType == ExtensionDataNodeType.ReferencedElement ||
            nodeType == ExtensionDataNodeType.NullElement);
 }
Example #40
0
 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);
             _nextElement.AddAttribute(Globals.XsiPrefix, Globals.SchemaInstanceNamespace, Globals.XsiNilLocalName, Globals.True);
             _internalNodeType = ExtensionDataNodeType.ReferencedElement;
         }
         else
         {
             _cache.Add(node, node);
         }
     }
     return handled;
 }