public void WriteMembers(object instance, ISerialiserNode parentNode, Type type)
        {
            var typeName = typeNamesCache.GetTypeName(type);

            using (var dictNode = ownerDocument.CreateTypedElement("dict", typeName, parentNode))
            {
                WriteItems(dictNode, (IDictionary)instance);
            }
        }
Exemple #2
0
        public void WriteMembers(object instance, ISerialiserNode parentNode, Type type)
        {
            var typeName = typeNamesCache.GetTypeName(type);

            using (var listNode = ownerDocument.CreateListElement(typeName, parentNode))
            {
                WriteItems(listNode, (IList)instance);
            }
        }
Exemple #3
0
        public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
        {
            var valueID  = valuesCache.Add(instance);
            var typeName = typeNamesCache.GetTypeName(instance.GetType());

            using (var arrayNode = ownerDocument.CreateTypedElement("arrayOfDoubles",
                                                                    typeName, parentNode))
            {
                arrayNode.AddAttribute("ID", valueID.ToString());

                using (var itemsNode = ownerDocument.CreateElement("items", arrayNode))
                {
                    var values = (Array)instance;
                    itemsNode.AddAttribute("count", values.Length);

                    var innerText         = new StringBuilder();
                    var itemsPerLineCount = 0;
                    foreach (var listItem in values)
                    {
                        innerText.AppendFormat("{0},", listItem);
                        if (++itemsPerLineCount == 10)
                        {
                            itemsPerLineCount = 0;
                            innerText.AppendFormat("\r\n");
                        }
                    }

                    itemsNode.InnerText = innerText.ToString();
                }
            }
        }
        public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
        {
            var objectID = valuesCache.Add(instance);
            var typeName = typeNamesCache.GetTypeName(referencedAsType);

            using (ownerDocument.CreateAppObjectElement(typeName, objectID, parentNode))
            {
            }
        }
        public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
        {
            var typeName = typeNamesCache.GetTypeName(instance.GetType());

            using (var valueNode = ownerDocument.CreateTypedElement("enum",
                                                                    typeName,
                                                                    parentNode))
            {
                valueNode.InnerText = Enum.GetName(instance.GetType(), instance);
            }
        }
Exemple #6
0
        public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
        {
            var typeName = typeNamesCache.GetTypeName(instance.GetType());

            using (
                var node = ownerDocument.CreateValueElement(typeName, parentNode))
            {
                using (var membersNode = ownerDocument.CreateMembersElement(node))
                {
                    memberWriter.Write(instance, membersNode, instance.GetType());
                }
            }
        }
        public void WriteMembers(object instance, ISerialiserNode parentNode, Type type)
        {
            var typeName = typeNamesCache.GetTypeName(type);

            using (
                var baseClassNode = ownerDocument.CreateBaseClassElement(typeName, parentNode))
            {
                using (var membersNode = ownerDocument.CreateMembersElement(baseClassNode))
                {
                    memberWriter.Write(instance, membersNode, type);
                }
                baseTypeMembersWriter.WriteMembers(instance, baseClassNode, type);
            }
        }
Exemple #8
0
        public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
        {
            var objectID = valuesCache.Add(instance);
            var typeName = typeNamesCache.GetTypeName(instance.GetType());

            using (var classNode = ownerDocument.CreateClassElement(typeName, objectID, parentNode))
            {
                using (var membersNode = ownerDocument.CreateMembersElement(classNode))
                {
                    memberWriter.Write(instance, membersNode, instance.GetType());
                }

                baseTypeMembersWriter.WriteMembers(instance, classNode, instance.GetType());
            }
        }
        public void Write(object instance, INodeWriter parentNode, Type referencedAsType)
        {
            var valueID  = valuesCache.Add(instance);
            var typeName = typeNamesCache.GetTypeName(instance.GetType());

            using (var arrayNode = ownerDocument.CreateArrayElement(
                       typeName, valueID, parentNode))
            {
                using (var itemsNode = ownerDocument.CreateItemsElement(arrayNode))
                {
                    foreach (var listItem in (IEnumerable)instance)
                    {
                        var itemType = listItem == null?instance.GetType().GetElementType() : listItem.GetType();

                        objectWriter.Write(listItem, itemsNode, itemType);
                    }
                }
            }
        }