public void Deserialize(TextReader reader)
        {
            try
            {
                this.StartDeserialization();

                XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();

                //JsonConvert.DeserializeXNode
                //var test = reader.ReadLine();

                //var jsonReader = new JsonTextReader(reader);
                //jsonReader.Read();


                //var readXml = (XmlDocument)xmlNodeConverter.ReadJson(jsonReader, typeof(XmlDocument), null, _serializer);

                var         readXml = JsonConvert.DeserializeXNode(reader.ReadToEnd());
                XmlDocument doc     = new XmlDocument();
                doc.LoadXml(readXml.ToString());

                //#TODO this be broke

                LayoutRoot layout = new XmlSerializer(typeof(LayoutRoot)).Deserialize(new XmlNodeReader(doc)) as LayoutRoot;
                this.FixupLayout(layout);
                this.Manager.Layout = layout;
            }
            finally
            {
                this.EndDeserialization();
            }
        }
        public static string SerializeXmlNode(System.Xml.XmlNode node, Newtonsoft.Json.Formatting formatting)
        {
            XmlNodeConverter converter = new XmlNodeConverter();

            JsonConverter[] converters = new JsonConverter[] { converter };
            return(SerializeObject(node, formatting, converters));
        }
        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);
        }
Exemple #4
0
        /// <summary>
        /// Deserializes the XmlNode from a JSON string nested in a root elment.
        /// </summary>
        /// <param name="value">The JSON string.</param>
        /// <param name="deserializeRootElementName">The name of the root element to append when deserializing.</param>
        /// <returns>The deserialized XmlNode</returns>
        public static XmlDocument DeserializeXmlNode(string value, string deserializeRootElementName)
        {
            XmlNodeConverter converter = new XmlNodeConverter();

            converter.DeserializeRootElementName = deserializeRootElementName;

            return((XmlDocument)DeserializeObject(value, typeof(XmlDocument), converter));
        }
        public static XmlDocument DeserializeXmlNode(string value, string deserializeRootElementName, bool writeArrayAttribute)
        {
            XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();

            xmlNodeConverter.DeserializeRootElementName = deserializeRootElementName;
            xmlNodeConverter.WriteArrayAttribute        = writeArrayAttribute;
            return((XmlDocument)DeserializeObject(value, typeof(XmlDocument), xmlNodeConverter));
        }
Exemple #6
0
        public static string SerializeXNode(XObject node, Newtonsoft.Json.Formatting formatting, bool omitRootObject)
        {
            XmlNodeConverter converter = new XmlNodeConverter {
                OmitRootObject = omitRootObject
            };

            return(SerializeObject(node, formatting, new JsonConverter[] { converter }));
        }
Exemple #7
0
        /// <summary>
        /// Serializes the <see cref="XmlNode"/> to a JSON string using formatting and omits the root object if <paramref name="omitRootObject"/> is <c>true</c>.
        /// </summary>
        /// <param name="node">The node to serialize.</param>
        /// <param name="formatting">Indicates how the output should be formatted.</param>
        /// <param name="omitRootObject">Omits writing the root object.</param>
        /// <returns>A JSON string of the <see cref="XmlNode"/>.</returns>
        public static string SerializeXmlNode(XmlNode node, Formatting formatting, bool omitRootObject)
        {
            XmlNodeConverter converter = new XmlNodeConverter {
                OmitRootObject = omitRootObject
            };

            return(SerializeObject(node, formatting, converter));
        }
        public static string SerializeXmlNode(XmlNode node, Formatting formatting)
        {
            XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();

            return(JsonConvert.SerializeObject(node, formatting, new JsonConverter[]
            {
                xmlNodeConverter
            }));
        }
        public static string SerializeXmlNode(XmlNode node, Formatting formatting, bool omitRootObject)
        {
            XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();

            xmlNodeConverter.OmitRootObject = omitRootObject;
            XmlNodeConverter xmlNodeConverter2 = xmlNodeConverter;

            return(SerializeObject(node, formatting, xmlNodeConverter2));
        }
        /// <summary>
        /// Serializes the <see cref="T:System.Xml.Linq.XNode" /> to a JSON string using formatting and omits the root object if <paramref name="omitRootObject" /> is <c>true</c>.
        /// </summary>
        /// <param name="node">The node to serialize.</param>
        /// <param name="formatting">Indicates how the output is formatted.</param>
        /// <param name="omitRootObject">Omits writing the root object.</param>
        /// <returns>A JSON string of the XNode.</returns>
        public static string SerializeXNode(XObject node, Formatting formatting, bool omitRootObject)
        {
            XmlNodeConverter xmlNodeConverter = new XmlNodeConverter()
            {
                OmitRootObject = omitRootObject
            };

            return(JsonConvert.SerializeObject((object)node, formatting, (JsonConverter)xmlNodeConverter));
        }
Exemple #11
0
        public static XDocument DeserializeXNode(string value, string deserializeRootElementName, bool writeArrayAttribute)
        {
            XmlNodeConverter converter = new XmlNodeConverter {
                DeserializeRootElementName = deserializeRootElementName,
                WriteArrayAttribute        = writeArrayAttribute
            };

            return((XDocument)DeserializeObject(value, typeof(XDocument), new JsonConverter[] { converter }));
        }
Exemple #12
0
        /// <summary>
        /// Deserializes the <see cref="XNode"/> from a JSON string nested in a root element specified by <paramref name="deserializeRootElementName"/>,
        /// writes a Json.NET array attribute for collections, and encodes special characters.
        /// </summary>
        /// <param name="value">The JSON string.</param>
        /// <param name="deserializeRootElementName">The name of the root element to append when deserializing.</param>
        /// <param name="writeArrayAttribute">
        /// A value to indicate whether to write the Json.NET array attribute.
        /// This attribute helps preserve arrays when converting the written XML back to JSON.
        /// </param>
        /// <param name="encodeSpecialCharacters">
        /// A value to indicate whether to encode special characters when converting JSON to XML.
        /// If <c>true</c>, special characters like ':', '@', '?', '#' and '$' in JSON property names aren't used to specify
        /// XML namespaces, attributes or processing directives. Instead special characters are encoded and written
        /// as part of the XML element name.
        /// </param>
        /// <returns>The deserialized <see cref="XNode"/>.</returns>
        public static XDocument DeserializeXNode(string value, string deserializeRootElementName, bool writeArrayAttribute, bool encodeSpecialCharacters)
        {
            XmlNodeConverter converter = new XmlNodeConverter();

            converter.DeserializeRootElementName = deserializeRootElementName;
            converter.WriteArrayAttribute        = writeArrayAttribute;
            converter.EncodeSpecialCharacters    = encodeSpecialCharacters;

            return((XDocument)DeserializeObject(value, typeof(XDocument), converter));
        }
Exemple #13
0
        public static XDocument DeserializeXNode(string value, string deserializeRootElementName, bool writeArrayAttribute, bool encodeSpecialCharacters)
        {
            XmlNodeConverter xmlNodeConverter = new XmlNodeConverter()
            {
                DeserializeRootElementName = deserializeRootElementName,
                WriteArrayAttribute        = writeArrayAttribute,
                EncodeSpecialCharacters    = encodeSpecialCharacters
            };

            return((XDocument)JsonConvert.DeserializeObject(value, typeof(XDocument), new JsonConverter[] { xmlNodeConverter }));
        }
        public static XmlDocument DeserializeXmlNode(string value, string deserializeRootElementName, bool writeArrayAttribute)
        {
            XmlNodeConverter xmlNodeConverter = new XmlNodeConverter()
            {
                DeserializeRootElementName = deserializeRootElementName,
                WriteArrayAttribute        = writeArrayAttribute
            };
            XmlNodeConverter xmlNodeConverter1 = xmlNodeConverter;

            return((XmlDocument)JsonConvert.DeserializeObject(value, typeof(XmlDocument), new JsonConverter[] { xmlNodeConverter1 }));
        }
Exemple #15
0
        public static XmlDocument DeserializeXmlNode([Nullable(1)] string value, string deserializeRootElementName, bool writeArrayAttribute, bool encodeSpecialCharacters)
        {
            XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();

            xmlNodeConverter.DeserializeRootElementName = deserializeRootElementName;
            xmlNodeConverter.WriteArrayAttribute        = writeArrayAttribute;
            xmlNodeConverter.EncodeSpecialCharacters    = encodeSpecialCharacters;
            return((XmlDocument)JsonConvert.DeserializeObject(value, typeof(XmlDocument), new JsonConverter[]
            {
                xmlNodeConverter
            }));
        }
Exemple #16
0
        private string XmlToJson(string xmlFileName)
        {
            //xml转换成json
            XmlDocument doc = new XmlDocument();

            doc.Load(xmlFileName);
            XmlNodeConverter converter = new XmlNodeConverter();
            string           jsonText  = JsonConvert.SerializeXmlNode(doc.GetElementsByTagName("root")[0], Newtonsoft.Json.Formatting.Indented);

            this._jsonText = jsonText;
            return(jsonText);
        }
        public static string SerializeXNode(XObject node, Formatting formatting, bool omitRootObject)
        {
            XmlNodeConverter xmlNodeConverter = new XmlNodeConverter
            {
                OmitRootObject = omitRootObject
            };

            return(JsonConvert.SerializeObject(node, formatting, new JsonConverter[]
            {
                xmlNodeConverter
            }));
        }
        public void Serialize(JsonWriter writer)
        {
            XmlDocument doc = new XmlDocument();

            using (XmlWriter xmlWriter = doc.CreateNavigator().AppendChild())
            {
                new System.Xml.Serialization.XmlSerializer(typeof(LayoutRoot)).Serialize(xmlWriter, (object)this.Manager.Layout);
                XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();
                xmlNodeConverter.WriteJson(writer, doc, _serializer);
            }

            //_serializer.Serialize(writer, (object) this.Manager.Layout);
        }
Exemple #19
0
        public static XDocument ToXNode(this JToken token, string deserializeRootElementName, bool writeArrayAttribute)
        {
            var converter = new XmlNodeConverter
            {
                DeserializeRootElementName = deserializeRootElementName,
                WriteArrayAttribute        = writeArrayAttribute
            };

            return(token.ToObject <XDocument>(JsonSerializer.Create(new JsonSerializerSettings
            {
                Converters = new JsonConverter[] { converter }
            })));
        }
    public override void WriteJson(JsonWriter writer, DataSet dataSet, JsonSerializer serializer)
    {
        var document = new XDocument();

        using (var xmlWriter = document.CreateWriter())
        {
            dataSet.WriteXml(xmlWriter, XmlWriteMode.WriteSchema);
        }
        var converter = new XmlNodeConverter {
            OmitRootObject = false
        };

        converter.WriteJson(writer, document, serializer);
    }
Exemple #21
0
    public override DataSet ReadJson(JsonReader reader, Type objectType, DataSet existingValue, bool hasExistingValue, JsonSerializer serializer)
    {
        var converter = new XmlNodeConverter {
            OmitRootObject = false
        };
        var document = (XDocument)converter.ReadJson(reader.MoveToContent(), typeof(XDocument), null, serializer);

        using (var xmlReader = document.CreateReader())
        {
            var dataSet = new DataSet();
            dataSet.ReadXml(xmlReader);
            return(dataSet);
        }
    }
Exemple #22
0
        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);
        }
        /// <summary>
        /// Deserializes the XmlNode from a JSON string nested in a root elment specified by <paramref name="deserializeRootElementName"/>.
        /// Note that DateParseHandling is set to DateParseHandling.None to avoid issues with DateTime strings when converting json to xml.
        /// </summary>
        /// <param name="value">The JSON string.</param>
        /// <param name="deserializeRootElementName">The name of the root element to append when deserializing.</param>
        /// <returns>The deserialized XmlNode</returns>
        private static XmlDocument DeserializeXmlNode(string value, string deserializeRootElementName = null)
        {
            var nodeConvertor = new XmlNodeConverter
            {
                DeserializeRootElementName = deserializeRootElementName,
                WriteArrayAttribute        = false
            };

            var serializerSettings = new JsonSerializerSettings
            {
                Converters = new[]
                {
                    (JsonConverter)nodeConvertor
                },
                DateParseHandling = DateParseHandling.None
            };

            return((XmlDocument)JsonConvert.DeserializeObject(value, typeof(XmlDocument), serializerSettings));
        }
Exemple #24
0
        public Message ConvertToXmlMessage(Message message)
        {
            MemoryStream        ms     = new MemoryStream();
            XmlDictionaryWriter writer = JsonReaderWriterFactory.CreateJsonWriter(ms);

            message.WriteMessage(writer);
            writer.Flush();
            string jsonString = Encoding.UTF8.GetString(ms.ToArray());

            XmlNodeConverter xmlNodeConverter = new XmlNodeConverter();
            XmlDocument      myXmlNode        = JsonConvert.DeserializeXmlNode(jsonString);
            MemoryStream     stream           = new MemoryStream(Encoding.UTF8.GetBytes(myXmlNode.InnerXml));

            XmlReader reader     = XmlReader.Create(stream);
            Message   newMessage = Message.CreateMessage(reader, int.MaxValue, MessageVersion.None);

            newMessage.Properties.CopyProperties(message.Properties);
            return(newMessage);
        }
        /// <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 GetXmlFromDocument(XmlDocument document)
        {
            _MyModel = null;

            foreach (XmlNode node in document.FirstChild.ChildNodes)
            {
                if (node.LocalName == "SpecialsRotterdam")
                {
                    _MyModel = XmlNodeConverter.ConvertNode <SpecialsRotterdamModel>(node);
                    break;
                }
            }

            if (_MyModel == null)
            {
                _MyModel = new SpecialsRotterdamModel();
            }
            _SpecialsRotterdamTabVM.Specials = _MyModel;
            _SpecialsRotterdamTabVM.RaisePropertyChanged("");
        }
Exemple #27
0
        public static String CsdlToJson(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();
                // May need to put this back.
                // converter.OmitRootObject = true;
                // doesn't seem to do anything.
                // converter.WriteArrayAttribute = true;
                jsonSerializer.Converters.Add(converter);
                jsonSerializer.Serialize(jsonWriter, xDoc);
            }

            var jsonText = sw.ToString();

            return(jsonText);
        }
Exemple #28
0
        public void GetXmlFromDocument(XmlDocument document)
        {
            _MyModel = null;

            foreach (XmlNode node in document.FirstChild.ChildNodes)
            {
                if (node.LocalName == "SumoKoppeling")
                {
                    _MyModel = XmlNodeConverter.ConvertNode <SumoDataModel>(node);
                    break;
                }
            }

            if (_MyModel == null)
            {
                _MyModel = new SumoDataModel();
            }
            _sumoPluginViewModel.Data = _MyModel;
            _sumoPluginViewModel.FaseCycli.BubbleSort();
            _sumoPluginViewModel.Detectoren.BubbleSort();
            _sumoPluginViewModel.RaisePropertyChanged("");
        }
Exemple #29
0
        public void GetXmlFromDocument(XmlDocument document)
        {
            _MyModel = null;

            foreach (XmlNode node in document.FirstChild.ChildNodes)
            {
                if (node.LocalName == "SpecialsDenHaag")
                {
                    _MyModel = XmlNodeConverter.ConvertNode <SpecialsDenHaagModel>(node);
                    break;
                }
            }

            if (_MyModel == null)
            {
                _MyModel = new SpecialsDenHaagModel();
            }
            _SpecialsDenHaagTabVM.Specials = _MyModel;
            _SpecialsDenHaagTabVM.AlternatievenPerBlok.BubbleSort();
            _SpecialsDenHaagTabVM.RaisePropertyChanged("");
            _ovmModule = new DVMModuleDenHaag();
        }
Exemple #30
0
        public void GetXmlFromDocument(XmlDocument document)
        {
            bool found = false;

            foreach (XmlNode node in document.FirstChild.ChildNodes)
            {
                if (node.LocalName == "GebruikersOpties")
                {
                    MyGebruikersOpties = XmlNodeConverter.ConvertNode <GebruikersOptiesModel>(node);
                    found = true;
                    break;
                }
            }

            if (found)
            {
                Uitgangen         = new ObservableCollectionAroundList <GebruikersOptieWithIOViewModel, GebruikersOptieWithIOModel>(_MyGebruikersOpties.Uitgangen);
                Ingangen          = new ObservableCollectionAroundList <GebruikersOptieWithIOViewModel, GebruikersOptieWithIOModel>(_MyGebruikersOpties.Ingangen);
                HulpElementen     = new ObservableCollectionAroundList <GebruikersOptieViewModel, GebruikersOptieModel>(_MyGebruikersOpties.HulpElementen);
                Timers            = new ObservableCollectionAroundList <GebruikersOptieViewModel, GebruikersOptieModel>(_MyGebruikersOpties.Timers);
                Counters          = new ObservableCollectionAroundList <GebruikersOptieViewModel, GebruikersOptieModel>(_MyGebruikersOpties.Counters);
                Schakelaars       = new ObservableCollectionAroundList <GebruikersOptieViewModel, GebruikersOptieModel>(_MyGebruikersOpties.Schakelaars);
                GeheugenElementen = new ObservableCollectionAroundList <GebruikersOptieViewModel, GebruikersOptieModel>(_MyGebruikersOpties.GeheugenElementen);
                Parameters        = new ObservableCollectionAroundList <GebruikersOptieViewModel, GebruikersOptieModel>(_MyGebruikersOpties.Parameters);

                _AlleOpties = new object[8];
                _AlleOpties[UitgangenConst]         = Uitgangen;
                _AlleOpties[IngangenConst]          = Ingangen;
                _AlleOpties[HulpElementenConst]     = HulpElementen;
                _AlleOpties[TimersConst]            = Timers;
                _AlleOpties[CountersConst]          = Counters;
                _AlleOpties[SchakelaarsConst]       = Schakelaars;
                _AlleOpties[GeheugenElementenConst] = GeheugenElementen;
                _AlleOpties[ParametersConst]        = Parameters;

                RaisePropertyChanged("");
            }
        }
    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;
    }