Converts an XmlNode to and from JSON.
Inheritance: JsonConverter
        private void ReadElement(JsonReader reader, IXmlDocument document, IXmlNode currentNode, string propertyName, XmlNamespaceManager manager)
        {
            if (string.IsNullOrEmpty(propertyName))
            {
                throw JsonSerializationException.Create(reader, "XmlNodeConverter cannot convert JSON with an empty property name to XML.");
            }
            Dictionary <string, string> strs = this.ReadAttributeElements(reader, manager);
            string prefix = MiscellaneousUtils.GetPrefix(propertyName);

            if (propertyName.StartsWith('@'))
            {
                string str     = propertyName.Substring(1);
                string prefix1 = MiscellaneousUtils.GetPrefix(str);
                XmlNodeConverter.AddAttribute(reader, document, currentNode, str, manager, prefix1);
                return;
            }
            if (propertyName.StartsWith('$'))
            {
                if (propertyName == "$values")
                {
                    propertyName = propertyName.Substring(1);
                    prefix       = manager.LookupPrefix("http://james.newtonking.com/projects/json");
                    this.CreateElement(reader, document, currentNode, propertyName, manager, prefix, strs);
                    return;
                }
                if (propertyName == "$id" || propertyName == "$ref" || propertyName == "$type" || propertyName == "$value")
                {
                    string str1 = propertyName.Substring(1);
                    string str2 = manager.LookupPrefix("http://james.newtonking.com/projects/json");
                    XmlNodeConverter.AddAttribute(reader, document, currentNode, str1, manager, str2);
                    return;
                }
            }
            this.CreateElement(reader, document, currentNode, propertyName, manager, prefix, strs);
        }
Exemplo n.º 2
0
    private XmlNode DeserializeXmlNode(string json, string deserializeRootElementName)
    {
      JsonTextReader reader;

      reader = new JsonTextReader(new StringReader(json));
      reader.Read();
      XmlNodeConverter converter = new XmlNodeConverter();
      if (deserializeRootElementName != null)
        converter.DeserializeRootElementName = deserializeRootElementName;

      XmlNode node = (XmlNode)converter.ReadJson(reader, typeof (XmlDocument), null, new JsonSerializer());

#if !NET20
     string xmlText = node.OuterXml;

      reader = new JsonTextReader(new StringReader(json));
      reader.Read();
      XDocument d = (XDocument) converter.ReadJson(reader, typeof (XDocument), null, new JsonSerializer());

      string linqXmlText = d.ToString(SaveOptions.DisableFormatting);
      if (d.Declaration != null)
        linqXmlText = d.Declaration + linqXmlText;

      Assert.AreEqual(xmlText, linqXmlText);
#endif

      return node;
    }
    public static String XDocToJson(XDocument xDoc) {

      var sw = new StringWriter();
      using (var jsonWriter = new JsonPropertyFixupWriter(sw)) {
        // jsonWriter.Formatting = Newtonsoft.Json.Formatting.Indented;
        var jsonSerializer = new JsonSerializer();
        var converter = new XmlNodeConverter();
        jsonSerializer.Converters.Add(converter);
        jsonSerializer.Serialize(jsonWriter, xDoc);
      }

      var jsonText = sw.ToString();
      return jsonText;
    }
Exemplo n.º 4
0
        /// <summary>
        /// Initializes a new instance of the <see cref="JsonInterpreter"/> class.
        /// </summary>
        /// <param name="source">The <see cref="IResource"/>.</param>
        public JsonInterpreter(IResource source) : base(source)
        {
            string xmlContents = string.Empty;
            using(source)
            {
                JsonReader reader = new JsonTextReader(new StreamReader(source.Stream));
                reader.Read();

                XmlNodeConverter toXml = new XmlNodeConverter();
                XmlDocument xmlDoc = (XmlDocument)toXml.ReadJson(reader, typeof(XmlDocument));
                xmlContents = xmlDoc.OuterXml;
                reader.Close();                
            }

            IResource resource = new StaticContentResource(xmlContents);

            xmlInterpreter = new XmlConfigurationInterpreter(resource);
        }
        public void ConvertNullString()
        {
            JObject json = new JObject();
            json["Prop1"] = (string)null;
            json["Prop2"] = new MyModel().MyProperty;

            var xmlNodeConverter = new XmlNodeConverter { DeserializeRootElementName = "object" };
            var jsonSerializerSettings = new JsonSerializerSettings { Converters = new JsonConverter[] { xmlNodeConverter } };
            var jsonSerializer = JsonSerializer.CreateDefault(jsonSerializerSettings);
            XDocument d = json.ToObject<XDocument>(jsonSerializer);

            StringAssert.Equals(@"<object>
  <Prop1 />
  <Prop2 />
</object>", d.ToString());
        }
Exemplo n.º 6
0
        private void SerializeNode(
            JsonWriter writer,
            IXmlNode node,
            XmlNamespaceManager manager,
            bool writePropertyName)
        {
            switch (node.NodeType)
            {
            case XmlNodeType.Element:
                if (this.IsArray(node) && XmlNodeConverter.AllSameName(node) && node.ChildNodes.Count > 0)
                {
                    this.SerializeGroupedNodes(writer, node, manager, false);
                    break;
                }
                manager.PushScope();
                foreach (IXmlNode attribute in node.Attributes)
                {
                    if (attribute.NamespaceUri == "http://www.w3.org/2000/xmlns/")
                    {
                        string prefix = attribute.LocalName != "xmlns" ? XmlConvert.DecodeName(attribute.LocalName) : string.Empty;
                        string uri    = attribute.Value;
                        manager.AddNamespace(prefix, uri);
                    }
                }
                if (writePropertyName)
                {
                    writer.WritePropertyName(this.GetPropertyName(node, manager));
                }
                if (!this.ValueAttributes(node.Attributes) && node.ChildNodes.Count == 1 && node.ChildNodes[0].NodeType == XmlNodeType.Text)
                {
                    writer.WriteValue(node.ChildNodes[0].Value);
                }
                else if (node.ChildNodes.Count == 0 && CollectionUtils.IsNullOrEmpty <IXmlNode>((ICollection <IXmlNode>)node.Attributes))
                {
                    if (((IXmlElement)node).IsEmpty)
                    {
                        writer.WriteNull();
                    }
                    else
                    {
                        writer.WriteValue(string.Empty);
                    }
                }
                else
                {
                    writer.WriteStartObject();
                    for (int index = 0; index < node.Attributes.Count; ++index)
                    {
                        this.SerializeNode(writer, node.Attributes[index], manager, true);
                    }
                    this.SerializeGroupedNodes(writer, node, manager, true);
                    writer.WriteEndObject();
                }
                manager.PopScope();
                break;

            case XmlNodeType.Attribute:
            case XmlNodeType.Text:
            case XmlNodeType.CDATA:
            case XmlNodeType.ProcessingInstruction:
            case XmlNodeType.Whitespace:
            case XmlNodeType.SignificantWhitespace:
                if (node.NamespaceUri == "http://www.w3.org/2000/xmlns/" && node.Value == "http://james.newtonking.com/projects/json" || node.NamespaceUri == "http://james.newtonking.com/projects/json" && node.LocalName == "Array")
                {
                    break;
                }
                if (writePropertyName)
                {
                    writer.WritePropertyName(this.GetPropertyName(node, manager));
                }
                writer.WriteValue(node.Value);
                break;

            case XmlNodeType.Comment:
                if (!writePropertyName)
                {
                    break;
                }
                writer.WriteComment(node.Value);
                break;

            case XmlNodeType.Document:
            case XmlNodeType.DocumentFragment:
                this.SerializeGroupedNodes(writer, node, manager, writePropertyName);
                break;

            case XmlNodeType.DocumentType:
                IXmlDocumentType xmlDocumentType = (IXmlDocumentType)node;
                writer.WritePropertyName(this.GetPropertyName(node, manager));
                writer.WriteStartObject();
                if (!string.IsNullOrEmpty(xmlDocumentType.Name))
                {
                    writer.WritePropertyName("@name");
                    writer.WriteValue(xmlDocumentType.Name);
                }
                if (!string.IsNullOrEmpty(xmlDocumentType.Public))
                {
                    writer.WritePropertyName("@public");
                    writer.WriteValue(xmlDocumentType.Public);
                }
                if (!string.IsNullOrEmpty(xmlDocumentType.System))
                {
                    writer.WritePropertyName("@system");
                    writer.WriteValue(xmlDocumentType.System);
                }
                if (!string.IsNullOrEmpty(xmlDocumentType.InternalSubset))
                {
                    writer.WritePropertyName("@internalSubset");
                    writer.WriteValue(xmlDocumentType.InternalSubset);
                }
                writer.WriteEndObject();
                break;

            case XmlNodeType.XmlDeclaration:
                IXmlDeclaration xmlDeclaration = (IXmlDeclaration)node;
                writer.WritePropertyName(this.GetPropertyName(node, manager));
                writer.WriteStartObject();
                if (!string.IsNullOrEmpty(xmlDeclaration.Version))
                {
                    writer.WritePropertyName("@version");
                    writer.WriteValue(xmlDeclaration.Version);
                }
                if (!string.IsNullOrEmpty(xmlDeclaration.Encoding))
                {
                    writer.WritePropertyName("@encoding");
                    writer.WriteValue(xmlDeclaration.Encoding);
                }
                if (!string.IsNullOrEmpty(xmlDeclaration.Standalone))
                {
                    writer.WritePropertyName("@standalone");
                    writer.WriteValue(xmlDeclaration.Standalone);
                }
                writer.WriteEndObject();
                break;

            default:
                throw new JsonSerializationException("Unexpected XmlNodeType when serializing nodes: " + (object)node.NodeType);
            }
        }
Exemplo n.º 7
0
        public static XmlNode DeerializeXmlNode(string value)
        {
            XmlNodeConverter converter = new XmlNodeConverter();

            return (XmlDocument)DeserializeObject(value, typeof(XmlDocument), converter);
        }
Exemplo n.º 8
0
        public static string SerializeXmlNode(XmlNode node)
        {
            XmlNodeConverter converter = new XmlNodeConverter();

            return SerializeObject(node, converter);
        }