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