Example #1
0
        private void SerializeDynamicObject(IDynamicMetaObjectProvider dynamicObject, bool startEle)
        {
            var flag = new AssertFlag();

            var dymgr = new DynamicManager();

            if (startEle)
            {
                xmlWriter.WriteStartElement("Dynamic");
            }

            var queue = new PriorityActionQueue();

            foreach (var name in dynamicObject.GetDynamicMemberNames())
            {
                object value;
                dymgr.TryGetMember(dynamicObject, name, out value);
                if (value == null)
                {
                    continue;
                }

                if (option.NodeStyle == XmlNodeStyle.Attribute && value.GetType().IsStringable())
                {
                    queue.Add(0, () =>
                    {
                        context.SerializeInfo = new PropertySerialzeInfo(ObjectType.DynamicObject, typeof(object), name);
                        xmlWriter.WriteAttributeString(name, value.ToString());
                        context.SerializeInfo = null;
                    });
                }
                else
                {
                    queue.Add(1, () =>
                    {
                        context.SerializeInfo = new PropertySerialzeInfo(ObjectType.DynamicObject, typeof(object), name);
                        WriteXmlElement(name, true, () => Serialize(value, type: value.GetType()));
                        context.SerializeInfo = null;
                    });
                }
            }

            queue.Invoke();

            if (startEle)
            {
                xmlWriter.WriteEndElement();
            }
        }
Example #2
0
        private void SerializeObject(object obj, bool startEle)
        {
            var lazyMgr = obj.As <ILazyManager>();
            var flag    = new AssertFlag();
            var type    = obj.GetType();

            if (startEle)
            {
                xmlWriter.WriteStartElement(GetElementName(type));
            }

            var cache = context.GetAccessorCache(type);
            var queue = new PriorityActionQueue();

            foreach (var acc in cache)
            {
                if (acc.Filter(acc.PropertyInfo, lazyMgr))
                {
                    continue;
                }

                var value = acc.Accessor.GetValue(obj);
                if (value == null)
                {
                    continue;
                }

                var objType = acc.PropertyInfo.PropertyType == typeof(object) ? value.GetType() : acc.PropertyInfo.PropertyType;
                if (option.NodeStyle == XmlNodeStyle.Attribute && objType.IsStringable())
                {
                    queue.Add(0, () =>
                    {
                        context.SerializeInfo = new PropertySerialzeInfo(acc);
                        if (acc.Converter != null)
                        {
                            xmlWriter.WriteAttributeString(acc.PropertyName, acc.Converter.WriteObject(serializer, value));
                        }
                        else
                        {
                            xmlWriter.WriteAttributeString(acc.PropertyName, value.ToString());
                        }

                        context.SerializeInfo = null;
                    });
                }
                else
                {
                    queue.Add(1, () =>
                    {
                        context.SerializeInfo = new PropertySerialzeInfo(acc);
                        if (acc.Converter != null && acc.Converter is XmlConverter converter)
                        {
                            WriteXmlElement(acc.PropertyName, true, () => converter.WriteXml(serializer, xmlWriter, value));
                        }
                        else
                        {
                            WriteXmlElement(acc.PropertyName, true, () => Serialize(value, type: objType));
                        }

                        context.SerializeInfo = null;
                    });
                }
            }

            queue.Invoke();

            if (startEle)
            {
                xmlWriter.WriteEndElement();
            }
        }
Example #3
0
        private void SerializeObject(object obj, bool startEle)
        {
            var lazyMgr = obj.As <ILazyManager>();
            var flag    = new AssertFlag();
            var type    = obj.GetType();

            if (startEle)
            {
                _xmlWriter.WriteStartElement(GetElementName(type));
            }

            var queue = new PriorityActionQueue();

            foreach (var metadata in _context.GetProperties(type, () => _option.ContractResolver.GetProperties(type)))
            {
                if (metadata.Filter(metadata.PropertyInfo, lazyMgr))
                {
                    continue;
                }

                var value = metadata.Getter.Invoke(obj);
                if ((_option.NullValueHandling == NullValueHandling.Ignore && value == null) ||
                    (value == null && _option.NodeStyle == XmlNodeStyle.Attribute))
                {
                    continue;
                }

                var objType = metadata.PropertyInfo.PropertyType == typeof(object) && value != null?value.GetType() : metadata.PropertyInfo.PropertyType;

                if (_option.NodeStyle == XmlNodeStyle.Attribute && objType.IsStringable())
                {
                    queue.Add(0, () =>
                    {
                        _context.SerializeInfo = new PropertySerialzeInfo(metadata);
                        if (metadata.Converter != null)
                        {
                            _xmlWriter.WriteAttributeString(metadata.PropertyName, metadata.Converter.WriteObject(_serializer, value));
                        }
                        else
                        {
                            _xmlWriter.WriteAttributeString(metadata.PropertyName, value.ToString());
                        }

                        _context.SerializeInfo = null;
                    });
                }
                else
                {
                    queue.Add(1, () =>
                    {
                        _context.SerializeInfo = new PropertySerialzeInfo(metadata);
                        if (metadata.Converter != null && metadata.Converter is XmlConverter converter)
                        {
                            WriteXmlElement(metadata.PropertyName, true, () => converter.WriteXml(_serializer, _xmlWriter, value));
                        }
                        else
                        {
                            WriteXmlElement(metadata.PropertyName, true, () => Serialize(value, type: objType));
                        }

                        _context.SerializeInfo = null;
                    });
                }
            }

            queue.Invoke();

            if (startEle)
            {
                _xmlWriter.WriteEndElement();
            }
        }