Optimise XmlNodeConverter (#1176)

* Short-circuit SerializeGroupedNodes on no child nodes.

Avoids creating unused Dictionary.

* Don't create Dictionary in ReadAttributeElements if it'll be empty.

* Reduce calls to JsonReader.TokenType virtual property.

* Remove duplicate finished boolean.

Different reasons for finishing the ReadAttributeElements loop are
noted, but the difference isn't acted on, so merge them.

* Check correct XML is from correct TokenType immediately.

(This changes the exception message in the case of it also being an
invalid objectType, but not the exception type).
This commit is contained in:
Jon Hanna
2017-01-15 18:14:00 +13:00
committed by James Newton-King
parent 0ef9ec292b
commit b3e2d61708
@@ -1177,6 +1177,11 @@ namespace Newtonsoft.Json.Converters
private void SerializeGroupedNodes(JsonWriter writer, IXmlNode node, XmlNamespaceManager manager, bool writePropertyName) private void SerializeGroupedNodes(JsonWriter writer, IXmlNode node, XmlNamespaceManager manager, bool writePropertyName)
{ {
if (node.ChildNodes.Count == 0)
{
return;
}
// group nodes together by name // group nodes together by name
Dictionary<string, List<IXmlNode>> nodesGroupedByName = new Dictionary<string, List<IXmlNode>>(); Dictionary<string, List<IXmlNode>> nodesGroupedByName = new Dictionary<string, List<IXmlNode>>();
@@ -1420,9 +1425,14 @@ namespace Newtonsoft.Json.Converters
/// <returns>The object value.</returns> /// <returns>The object value.</returns>
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer) public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{ {
if (reader.TokenType == JsonToken.Null) switch (reader.TokenType)
{ {
case JsonToken.Null:
return null; return null;
case JsonToken.StartObject:
break;
default:
throw new JsonSerializationException("XmlNodeConverter can only convert JSON that begins with an object.");
} }
XmlNamespaceManager manager = new XmlNamespaceManager(new NameTable()); XmlNamespaceManager manager = new XmlNamespaceManager(new NameTable());
@@ -1464,11 +1474,6 @@ namespace Newtonsoft.Json.Converters
throw new JsonSerializationException("Unexpected type when converting XML: " + objectType); throw new JsonSerializationException("Unexpected type when converting XML: " + objectType);
} }
if (reader.TokenType != JsonToken.StartObject)
{
throw new JsonSerializationException("XmlNodeConverter can only convert JSON that begins with an object.");
}
if (!string.IsNullOrEmpty(DeserializeRootElementName)) if (!string.IsNullOrEmpty(DeserializeRootElementName))
{ {
//rootNode = document.CreateElement(DeserializeRootElementName); //rootNode = document.CreateElement(DeserializeRootElementName);
@@ -1586,46 +1591,48 @@ namespace Newtonsoft.Json.Converters
currentNode.AppendChild(element); currentNode.AppendChild(element);
if (attributeNameValues != null)
{
// add attributes to newly created element // add attributes to newly created element
foreach (KeyValuePair<string, string> nameValue in attributeNameValues) foreach (KeyValuePair<string, string> nameValue in attributeNameValues)
{ {
string encodedName = XmlConvert.EncodeName(nameValue.Key); string encodedName = XmlConvert.EncodeName(nameValue.Key);
string attributePrefix = MiscellaneousUtils.GetPrefix(nameValue.Key); string attributePrefix = MiscellaneousUtils.GetPrefix(nameValue.Key);
IXmlNode attribute = (!string.IsNullOrEmpty(attributePrefix)) IXmlNode attribute = (!string.IsNullOrEmpty(attributePrefix)) ? document.CreateAttribute(encodedName, manager.LookupNamespace(attributePrefix) ?? string.Empty, nameValue.Value) : document.CreateAttribute(encodedName, nameValue.Value);
? document.CreateAttribute(encodedName, manager.LookupNamespace(attributePrefix) ?? string.Empty, nameValue.Value)
: document.CreateAttribute(encodedName, nameValue.Value);
element.SetAttributeNode(attribute); element.SetAttributeNode(attribute);
} }
}
if (reader.TokenType == JsonToken.String switch (reader.TokenType)
|| reader.TokenType == JsonToken.Integer
|| reader.TokenType == JsonToken.Float
|| reader.TokenType == JsonToken.Boolean
|| reader.TokenType == JsonToken.Date)
{ {
case JsonToken.String:
case JsonToken.Integer:
case JsonToken.Float:
case JsonToken.Boolean:
case JsonToken.Date:
string text = ConvertTokenToXmlValue(reader); string text = ConvertTokenToXmlValue(reader);
if (text != null) if (text != null)
{ {
element.AppendChild(document.CreateTextNode(text)); element.AppendChild(document.CreateTextNode(text));
} }
} break;
else if (reader.TokenType == JsonToken.Null) case JsonToken.Null:
{
// empty element. do nothing // empty element. do nothing
} break;
else case JsonToken.EndObject:
{
// finished element will have no children to deserialize // finished element will have no children to deserialize
if (reader.TokenType != JsonToken.EndObject) manager.RemoveNamespace(string.Empty, manager.DefaultNamespace);
{ break;
default:
manager.PushScope(); manager.PushScope();
DeserializeNode(reader, document, manager, element); DeserializeNode(reader, document, manager, element);
manager.PopScope(); manager.PopScope();
}
manager.RemoveNamespace(string.Empty, manager.DefaultNamespace); manager.RemoveNamespace(string.Empty, manager.DefaultNamespace);
break;
} }
} }
@@ -1648,60 +1655,49 @@ namespace Newtonsoft.Json.Converters
private string ConvertTokenToXmlValue(JsonReader reader) private string ConvertTokenToXmlValue(JsonReader reader)
{ {
if (reader.TokenType == JsonToken.String) switch (reader.TokenType)
{ {
case JsonToken.String:
return reader.Value?.ToString(); return reader.Value?.ToString();
} case JsonToken.Integer:
else if (reader.TokenType == JsonToken.Integer)
{
#if HAVE_BIG_INTEGER #if HAVE_BIG_INTEGER
if (reader.Value is BigInteger) if (reader.Value is BigInteger)
{ {
return ((BigInteger)reader.Value).ToString(CultureInfo.InvariantCulture); return ((BigInteger)reader.Value).ToString(CultureInfo.InvariantCulture);
} }
#endif #endif
return XmlConvert.ToString(Convert.ToInt64(reader.Value, CultureInfo.InvariantCulture)); return XmlConvert.ToString(Convert.ToInt64(reader.Value, CultureInfo.InvariantCulture));
} case JsonToken.Float:
else if (reader.TokenType == JsonToken.Float)
{
if (reader.Value is decimal) if (reader.Value is decimal)
{ {
return XmlConvert.ToString((decimal)reader.Value); return XmlConvert.ToString((decimal)reader.Value);
} }
if (reader.Value is float) if (reader.Value is float)
{ {
return XmlConvert.ToString((float)reader.Value); return XmlConvert.ToString((float)reader.Value);
} }
return XmlConvert.ToString(Convert.ToDouble(reader.Value, CultureInfo.InvariantCulture)); return XmlConvert.ToString(Convert.ToDouble(reader.Value, CultureInfo.InvariantCulture));
} case JsonToken.Boolean:
else if (reader.TokenType == JsonToken.Boolean)
{
return XmlConvert.ToString(Convert.ToBoolean(reader.Value, CultureInfo.InvariantCulture)); return XmlConvert.ToString(Convert.ToBoolean(reader.Value, CultureInfo.InvariantCulture));
} case JsonToken.Date:
else if (reader.TokenType == JsonToken.Date)
{
#if HAVE_DATE_TIME_OFFSET #if HAVE_DATE_TIME_OFFSET
if (reader.Value is DateTimeOffset) if (reader.Value is DateTimeOffset)
{ {
return XmlConvert.ToString((DateTimeOffset)reader.Value); return XmlConvert.ToString((DateTimeOffset)reader.Value);
} }
#endif
#endif
DateTime d = Convert.ToDateTime(reader.Value, CultureInfo.InvariantCulture); DateTime d = Convert.ToDateTime(reader.Value, CultureInfo.InvariantCulture);
#if !PORTABLE #if !PORTABLE
return XmlConvert.ToString(d, DateTimeUtils.ToSerializationMode(d.Kind)); return XmlConvert.ToString(d, DateTimeUtils.ToSerializationMode(d.Kind));
#else #else
return XmlConvert.ToString(d, DateTimeUtils.ToDateTimeFormat(d.Kind)); return XmlConvert.ToString(d, DateTimeUtils.ToDateTimeFormat(d.Kind));
#endif #endif
} case JsonToken.Null:
else if (reader.TokenType == JsonToken.Null)
{
return null; return null;
} default:
else
{
throw JsonSerializationException.Create(reader, "Cannot get an XML string value from token type '{0}'.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType)); throw JsonSerializationException.Create(reader, "Cannot get an XML string value from token type '{0}'.".FormatWith(CultureInfo.InvariantCulture, reader.TokenType));
} }
} }
@@ -1758,21 +1754,24 @@ namespace Newtonsoft.Json.Converters
private Dictionary<string, string> ReadAttributeElements(JsonReader reader, XmlNamespaceManager manager) private Dictionary<string, string> ReadAttributeElements(JsonReader reader, XmlNamespaceManager manager)
{ {
Dictionary<string, string> attributeNameValues = new Dictionary<string, string>();
bool finishedAttributes = false;
bool finishedElement = false;
// a string token means the element only has a single text child // a string token means the element only has a single text child
if (reader.TokenType != JsonToken.String switch (reader.TokenType)
&& reader.TokenType != JsonToken.Null
&& reader.TokenType != JsonToken.Boolean
&& reader.TokenType != JsonToken.Integer
&& reader.TokenType != JsonToken.Float
&& reader.TokenType != JsonToken.Date
&& reader.TokenType != JsonToken.StartConstructor)
{ {
case JsonToken.String:
case JsonToken.Null:
case JsonToken.Boolean:
case JsonToken.Integer:
case JsonToken.Float:
case JsonToken.Date:
case JsonToken.StartConstructor:
return null;
}
Dictionary<string, string> attributeNameValues = null;
bool finished = false;
// read properties until first non-attribute is encountered // read properties until first non-attribute is encountered
while (!finishedAttributes && !finishedElement && reader.Read()) while (!finished && reader.Read())
{ {
switch (reader.TokenType) switch (reader.TokenType)
{ {
@@ -1787,6 +1786,11 @@ namespace Newtonsoft.Json.Converters
switch (firstChar) switch (firstChar)
{ {
case '@': case '@':
if (attributeNameValues == null)
{
attributeNameValues = new Dictionary<string, string>();
}
attributeName = attributeName.Substring(1); attributeName = attributeName.Substring(1);
reader.Read(); reader.Read();
attributeValue = ConvertTokenToXmlValue(reader); attributeValue = ConvertTokenToXmlValue(reader);
@@ -1811,6 +1815,11 @@ namespace Newtonsoft.Json.Converters
string jsonPrefix = manager.LookupPrefix(JsonNamespaceUri); string jsonPrefix = manager.LookupPrefix(JsonNamespaceUri);
if (jsonPrefix == null) if (jsonPrefix == null)
{ {
if (attributeNameValues == null)
{
attributeNameValues = new Dictionary<string, string>();
}
// ensure that the prefix used is free // ensure that the prefix used is free
int? i = null; int? i = null;
while (manager.LookupNamespace("json" + i) != null) while (manager.LookupNamespace("json" + i) != null)
@@ -1826,7 +1835,7 @@ namespace Newtonsoft.Json.Converters
// special case $values, it will have a non-primitive value // special case $values, it will have a non-primitive value
if (attributeName == JsonTypeReflector.ArrayValuesPropertyName) if (attributeName == JsonTypeReflector.ArrayValuesPropertyName)
{ {
finishedAttributes = true; finished = true;
break; break;
} }
@@ -1838,36 +1847,38 @@ namespace Newtonsoft.Json.Converters
throw JsonSerializationException.Create(reader, "Unexpected JsonToken: " + reader.TokenType); throw JsonSerializationException.Create(reader, "Unexpected JsonToken: " + reader.TokenType);
} }
if (attributeNameValues == null)
{
attributeNameValues = new Dictionary<string, string>();
}
attributeValue = reader.Value?.ToString(); attributeValue = reader.Value?.ToString();
attributeNameValues.Add(jsonPrefix + ":" + attributeName, attributeValue); attributeNameValues.Add(jsonPrefix + ":" + attributeName, attributeValue);
break; break;
default: default:
finishedAttributes = true; finished = true;
break; break;
} }
break; break;
default: default:
finishedAttributes = true; finished = true;
break; break;
} }
} }
else else
{ {
finishedAttributes = true; finished = true;
} }
break; break;
case JsonToken.EndObject: case JsonToken.EndObject:
finishedElement = true;
break;
case JsonToken.Comment: case JsonToken.Comment:
finishedElement = true; finished = true;
break; break;
default: default:
throw JsonSerializationException.Create(reader, "Unexpected JsonToken: " + reader.TokenType); throw JsonSerializationException.Create(reader, "Unexpected JsonToken: " + reader.TokenType);
} }
} }
}
return attributeNameValues; return attributeNameValues;
} }
@@ -1996,7 +2007,7 @@ namespace Newtonsoft.Json.Converters
{ {
DeserializeValue(reader, document, manager, propertyName, currentNode); DeserializeValue(reader, document, manager, propertyName, currentNode);
} }
break; continue;
case JsonToken.StartConstructor: case JsonToken.StartConstructor:
string constructorName = reader.Value.ToString(); string constructorName = reader.Value.ToString();
@@ -2014,7 +2025,7 @@ namespace Newtonsoft.Json.Converters
default: default:
throw JsonSerializationException.Create(reader, "Unexpected JsonToken when deserializing node: " + reader.TokenType); throw JsonSerializationException.Create(reader, "Unexpected JsonToken when deserializing node: " + reader.TokenType);
} }
} while (reader.TokenType == JsonToken.PropertyName || reader.Read()); } while (reader.Read());
// don't read if current token is a property. token was already read when parsing element attributes // don't read if current token is a property. token was already read when parsing element attributes
} }