private object Read(JsonReader reader, IJsonSerializeOperationInfo info, string path)
{
if (reader.NodeType == JsonNodeType.Null)
{
return(null);
}
var dictionary = _createDictionary();
foreach (var keyString in reader.ReadProperties(path))
{
var key = _deserializeKey(keyString, info, path);
var value = _valueSerializer.DeserializeObject(reader, info, path.AppendProperty(keyString));
var jsonNumber = value as JsonNumber;
if (jsonNumber != null)
{
value = jsonNumber.DoubleValue;
}
_addToDictionary(dictionary, key, value);
}
return(dictionary);
}
private object Read(JsonReader reader, IJsonSerializeOperationInfo info)
{
string value;
switch (reader.NodeType)
{
case JsonNodeType.Number:
case JsonNodeType.String:
value = (string)reader.Value;
break;
case JsonNodeType.Boolean:
value = (bool)reader.Value ? "true" : "false";
break;
default:
if (_nullable && reader.NodeType == JsonNodeType.Null)
{
value = null;
}
else
{
throw new XSerializerException(string.Format(
"Unexpected node type '{0}' encountered in '{1}.DeserializeObject' method.",
reader.NodeType,
typeof(StringJsonSerializer)));
}
break;
}
return(_read(value, info));
}
private object Read(JsonReader reader, IJsonSerializeOperationInfo info, string path)
{
switch (reader.NodeType)
{
case JsonNodeType.Null:
case JsonNodeType.String:
case JsonNodeType.Boolean:
return(reader.Value);
case JsonNodeType.Number:
try
{
return(new JsonNumber((string)reader.Value));
}
catch (ArgumentException ex)
{
throw new MalformedDocumentException(MalformedDocumentError.InvalidValue,
path, reader.Value, reader.Line, reader.Position, ex);
}
case JsonNodeType.OpenObject:
return(DeserializeJsonObject(reader, info, path));
case JsonNodeType.OpenArray:
return(DeserializeJsonArray(reader, info, path));
case JsonNodeType.EndOfString:
throw new MalformedDocumentException(MalformedDocumentError.MissingValue,
path, reader.Line, reader.Position);
default:
throw new MalformedDocumentException(MalformedDocumentError.InvalidValue,
path, reader.Value, reader.Line, reader.Position);
}
}
private object Read(JsonReader reader, IJsonSerializeOperationInfo info, string path)
{
string value;
switch (reader.NodeType)
{
case JsonNodeType.Number:
case JsonNodeType.String:
value = (string)reader.Value;
break;
case JsonNodeType.Boolean:
value = (bool)reader.Value ? "true" : "false";
break;
default:
if (_nullable && reader.NodeType == JsonNodeType.Null)
{
value = null;
}
else
{
throw GetMissingOpenQuoteException(reader, path);
}
break;
}
return(_read(value, info, path, reader.Line, reader.Position));
}
public void SerializeObject(JsonWriter writer, object instance, IJsonSerializeOperationInfo info)
{
if (instance == null)
{
writer.WriteNull();
}
else
{
var serializer = _serializerCache.GetOrAdd(Tuple.Create(instance.GetType(), _encrypt), tuple => GetSerializer(tuple.Item1));
if (_encrypt)
{
var toggler = new EncryptWritesToggler(writer);
toggler.Toggle();
serializer.SerializeObject(writer, instance, info);
toggler.Revert();
}
else
{
serializer.SerializeObject(writer, instance, info);
}
}
}
public void SerializeObject(JsonWriter writer, object instance, IJsonSerializeOperationInfo info)
{
var jsonObject = (JsonObject)instance;
writer.WriteOpenObject();
var first = true;
foreach (var item in jsonObject)
{
if (first)
{
first = false;
}
else
{
writer.WriteItemSeparator();
}
writer.WriteValue(item.Key);
writer.WriteNameValueSeparator();
_dynamicJsonSerializer.SerializeObject(writer, item.Value, info);
}
writer.WriteCloseObject();
}
public object DeserializeObject(JsonReader reader, IJsonSerializeOperationInfo info, string path)
{
if (!reader.ReadContent(path))
{
if (reader.NodeType == JsonNodeType.EndOfString)
{
throw new MalformedDocumentException(MalformedDocumentError.MissingValue,
path, reader.Line, reader.Position);
}
Debug.Assert(reader.NodeType == JsonNodeType.Invalid);
if (reader.Value is string)
{
throw GetMissingCloseQuoteException(reader, path);
}
throw GetMissingOpenQuoteException(reader, path);
}
if (_encrypt)
{
var toggler = new DecryptReadsToggler(reader, path);
toggler.Toggle();
switch (reader.NodeType)
{
case JsonNodeType.Number:
case JsonNodeType.String:
case JsonNodeType.Boolean:
break;
case JsonNodeType.EndOfString:
throw new MalformedDocumentException(MalformedDocumentError.MissingValue,
path, reader.Line, reader.Position);
case JsonNodeType.Invalid:
if (reader.Value is string)
{
throw GetMissingCloseQuoteException(reader, path);
}
throw GetMissingOpenQuoteException(reader, path);
default:
throw GetMissingOpenQuoteException(reader, path);
}
try
{
return(Read(reader, info, path));
}
finally
{
toggler.Revert();
}
}
return(Read(reader, info, path));
}
private object Read(JsonReader reader, IJsonSerializeOperationInfo info)
{
string value;
switch (reader.NodeType)
{
case JsonNodeType.Number:
case JsonNodeType.String:
value = (string)reader.Value;
break;
case JsonNodeType.Boolean:
value = (bool)reader.Value ? "true" : "false";
break;
default:
if (_nullable && reader.NodeType == JsonNodeType.Null)
{
value = null;
}
else
{
throw new XSerializerException(string.Format(
"Unexpected node type '{0}' encountered in '{1}.DeserializeObject' method.",
reader.NodeType,
typeof(StringJsonSerializer)));
}
break;
}
return _read(value, info);
}
public object DeserializeObject(JsonReader reader, IJsonSerializeOperationInfo info)
{
if (!reader.ReadContent())
{
throw new XSerializerException("Unexpected end of input while attempting to parse '{' character.");
}
if (reader.NodeType == JsonNodeType.Null)
{
return(null);
}
if (_encrypt)
{
var toggler = new DecryptReadsToggler(reader);
toggler.Toggle();
try
{
return(Read(reader, info));
}
finally
{
toggler.Revert();
}
}
return(Read(reader, info));
}
private object DeserializeJsonArray(JsonReader reader, IJsonSerializeOperationInfo info)
{
var jsonArray = new JsonArray(info);
while (true)
{
if (reader.PeekNextNodeType() == JsonNodeType.CloseArray)
{
// If the next content is CloseArray, read it and return the empty list.
reader.Read();
return(jsonArray);
}
jsonArray.Add(DeserializeObject(reader, info));
if (!reader.ReadContent())
{
throw new XSerializerException("Unexpected end of input while attempting to parse ',' character.");
}
if (reader.NodeType == JsonNodeType.CloseArray)
{
break;
}
if (reader.NodeType != JsonNodeType.ItemSeparator)
{
throw new XSerializerException("Unexpected node type found while attempting to parse ',' character: " +
reader.NodeType + ".");
}
}
return(jsonArray);
}
public void SerializeObject(JsonWriter writer, object instance, IJsonSerializeOperationInfo info)
{
if (instance == null)
{
writer.WriteNull();
}
else
{
var serializer = _serializerCache.GetOrAdd(Tuple.Create(instance.GetType(), _encrypt), tuple => GetSerializer(tuple.Item1));
if (_encrypt)
{
var toggler = new EncryptWritesToggler(writer);
toggler.Toggle();
serializer.SerializeObject(writer, instance, info);
toggler.Revert();
}
else
{
serializer.SerializeObject(writer, instance, info);
}
}
}
public void WriteValue(JsonWriter writer, object instance, IJsonSerializeOperationInfo info)
{
var value = _getValue(instance);
writer.WriteValue(Name);
writer.WriteNameValueSeparator();
_serializer.Value.SerializeObject(writer, value, info);
}
public object DeserializeObject(
JsonReader reader, IJsonSerializeOperationInfo info, string path)
{
if (!reader.ReadContent(path))
{
if (reader.NodeType == JsonNodeType.Invalid)
{
throw new MalformedDocumentException(MalformedDocumentError.InvalidValue,
path, reader.Value, reader.Line, reader.Position);
}
Debug.Assert(reader.NodeType == JsonNodeType.EndOfString);
throw new MalformedDocumentException(MalformedDocumentError.MissingValue,
path, reader.Value, reader.Line, reader.Position);
}
if (_encrypt)
{
var toggler = new DecryptReadsToggler(reader, path);
if (toggler.Toggle())
{
if (reader.NodeType == JsonNodeType.Invalid)
{
throw new MalformedDocumentException(MalformedDocumentError.InvalidValue,
path, reader.Value, reader.Line, reader.Position);
}
var exception = false;
try
{
return(Read(reader, info, path));
}
catch (MalformedDocumentException)
{
exception = true;
throw;
}
finally
{
if (!exception)
{
if (reader.NodeType != JsonNodeType.Null && reader.DecryptReads && (reader.ReadContent(path) || reader.NodeType == JsonNodeType.Invalid))
{
throw new MalformedDocumentException(MalformedDocumentError.ExpectedEndOfDecryptedString,
path, reader.Value, reader.Line, reader.Position, null, reader.NodeType);
}
toggler.Revert();
}
}
}
}
return(Read(reader, info, path));
}
public object DeserializeObject(JsonReader reader, IJsonSerializeOperationInfo info, string path)
{
if (!reader.ReadContent(path))
{
if (reader.NodeType == JsonNodeType.EndOfString)
{
throw new MalformedDocumentException(MalformedDocumentError.MissingValue,
path, reader.Line, reader.Position);
}
Debug.Assert(reader.NodeType == JsonNodeType.Invalid);
if (reader.Value is string)
{
throw GetMissingCloseQuoteException(reader, path);
}
throw GetMissingOpenQuoteException(reader, path);
}
if (_encrypt)
{
var toggler = new DecryptReadsToggler(reader, path);
toggler.Toggle();
switch (reader.NodeType)
{
case JsonNodeType.Number:
case JsonNodeType.String:
case JsonNodeType.Boolean:
break;
case JsonNodeType.EndOfString:
throw new MalformedDocumentException(MalformedDocumentError.MissingValue,
path, reader.Line, reader.Position);
case JsonNodeType.Invalid:
if (reader.Value is string)
{
throw GetMissingCloseQuoteException(reader, path);
}
throw GetMissingOpenQuoteException(reader, path);
default:
throw GetMissingOpenQuoteException(reader, path);
}
try
{
return Read(reader, info, path);
}
finally
{
toggler.Revert();
}
}
return Read(reader, info, path);
}
public object DeserializeObject(
JsonReader reader, IJsonSerializeOperationInfo info, string path)
{
if (!reader.ReadContent(path))
{
if (reader.NodeType == JsonNodeType.Invalid)
{
throw new MalformedDocumentException(MalformedDocumentError.InvalidValue,
path, reader.Value, reader.Line, reader.Position);
}
Debug.Assert(reader.NodeType == JsonNodeType.EndOfString);
throw new MalformedDocumentException(MalformedDocumentError.MissingValue,
path, reader.Value, reader.Line, reader.Position);
}
if (_encrypt)
{
var toggler = new DecryptReadsToggler(reader, path);
if (toggler.Toggle())
{
if (reader.NodeType == JsonNodeType.Invalid)
{
throw new MalformedDocumentException(MalformedDocumentError.InvalidValue,
path, reader.Value, reader.Line, reader.Position);
}
var exception = false;
try
{
return Read(reader, info, path);
}
catch (MalformedDocumentException)
{
exception = true;
throw;
}
finally
{
if (!exception)
{
if (reader.ReadContent(path) || reader.NodeType == JsonNodeType.Invalid)
{
throw new MalformedDocumentException(MalformedDocumentError.ExpectedEndOfDecryptedString,
path, reader.Value, reader.Line, reader.Position, null, reader.NodeType);
}
toggler.Revert();
}
}
}
}
return Read(reader, info, path);
}
public static IJsonSerializeOperationInfo WithNewSerializationState(this IJsonSerializeOperationInfo info)
{
return(new JsonSerializeOperationInfo
{
EncryptionMechanism = info.EncryptionMechanism,
EncryptKey = info.EncryptKey,
SerializationState = new SerializationState(),
DateTimeHandler = info.DateTimeHandler
});
}
private object DeserializeJsonObject(JsonReader reader, IJsonSerializeOperationInfo info)
{
var jsonObject = new JsonObject(info);
foreach (var propertyName in reader.ReadProperties())
{
jsonObject.Add(propertyName, DeserializeObject(reader, info));
}
return(jsonObject);
}
public bool SetValue(JsonReader reader, string propertyName, IJsonSerializeOperationInfo info, string path)
{
SerializableJsonProperty property;
if (_serializablePropertiesMap.TryGetValue(propertyName, out property))
{
property.SetValue(_instance, reader, info, path);
return(true);
}
return(false);
}
private object Read(JsonReader reader, IJsonSerializeOperationInfo info)
{
var factory = _createObjectFactory.Value.Invoke();
foreach (var propertyName in reader.ReadProperties())
{
if (!factory.SetValue(reader, propertyName, info))
{
reader.Discard();
}
}
return(factory.GetInstance());
}
private object Read(JsonReader reader, IJsonSerializeOperationInfo info, string path)
{
var factory = _createObjectFactory.Value.Invoke();
foreach (var propertyName in reader.ReadProperties(path))
{
var propertyPath = path.AppendProperty(propertyName);
if (!factory.SetValue(reader, propertyName, info, propertyPath))
{
reader.Discard(propertyPath);
}
}
return(factory.GetInstance());
}
private object Read(JsonReader reader, IJsonSerializeOperationInfo info, string path)
{
if (reader.NodeType == JsonNodeType.Null)
{
return(null);
}
var list = _createList();
if (reader.PeekContent() == JsonNodeType.CloseArray)
{
// If the next content node is CloseArray, we're reading an empty
// array. Read the CloseArray node and return the empty list.
reader.Read(path);
return(_transformList(list));
}
var index = 0;
while (true)
{
var item = _itemSerializer.DeserializeObject(reader, info, path + "[" + index++ + "]");
_addItem(list, item);
if (!reader.ReadContent(path))
{
Debug.Assert(reader.NodeType == JsonNodeType.EndOfString);
throw new MalformedDocumentException(MalformedDocumentError.ArrayMissingCommaOrCloseSquareBracket,
path, reader.Line, reader.Position);
}
if (reader.NodeType == JsonNodeType.CloseArray)
{
break;
}
if (reader.NodeType != JsonNodeType.ItemSeparator)
{
throw new MalformedDocumentException(MalformedDocumentError.ArrayMissingCommaOrCloseSquareBracket,
path, reader.Value, reader.Line, reader.Position);
}
}
return(_transformList(list));
}
private static object Try(Func <string, IJsonSerializeOperationInfo, object> parseFunc,
string value, IJsonSerializeOperationInfo info, Type type, string path, int line, int position)
{
if (value == null)
{
return(null);
}
try
{
return(parseFunc(value, info));
}
catch (Exception ex)
{
throw new MalformedDocumentException(MalformedDocumentError.StringInvalidValue, path, value, line, position, ex, type);
}
}
private object Read(JsonReader reader, IJsonSerializeOperationInfo info)
{
var dictionary = _createDictionary();
foreach (var keyString in reader.ReadProperties())
{
var key = _deserializeKey(keyString, info);
var value = _valueSerializer.DeserializeObject(reader, info);
var jsonNumber = value as JsonNumber;
if (jsonNumber != null)
{
value = jsonNumber.DoubleValue;
}
_addToDictionary(dictionary, key, value);
}
return(dictionary);
}
private object Read(JsonReader reader, IJsonSerializeOperationInfo info)
{
if (reader.NodeType == JsonNodeType.Null)
{
return(null);
}
var list = _createList();
while (true)
{
if (reader.PeekNextNodeType() == JsonNodeType.CloseArray)
{
// If the next content is CloseArray, read it and return the empty list.
reader.Read();
return(list);
}
var item = _itemSerializer.DeserializeObject(reader, info);
_addItem(list, item);
if (!reader.ReadContent())
{
throw new XSerializerException("Unexpected end of input while attempting to parse ',' character.");
}
if (reader.NodeType == JsonNodeType.CloseArray)
{
break;
}
if (reader.NodeType != JsonNodeType.ItemSeparator)
{
throw new XSerializerException("Unexpected node type found while attempting to parse ',' character: " +
reader.NodeType + ".");
}
}
return(list);
}
private object Read(JsonReader reader, IJsonSerializeOperationInfo info)
{
switch (reader.NodeType)
{
case JsonNodeType.Null:
case JsonNodeType.String:
case JsonNodeType.Boolean:
return(reader.Value);
case JsonNodeType.Number:
return(new JsonNumber((string)reader.Value));
case JsonNodeType.OpenObject:
return(DeserializeJsonObject(reader, info));
case JsonNodeType.OpenArray:
return(DeserializeJsonArray(reader, info));
default:
throw new XSerializerException("Invalid json.");
}
}
public bool SetValue(JsonReader reader, string propertyName, IJsonSerializeOperationInfo info, string path)
{
var serializerAndArgIndex = _getSerializerAndArgIndex(propertyName);
if (serializerAndArgIndex != null)
{
var value = serializerAndArgIndex.Item1.DeserializeObject(reader, info, path + "." + propertyName);
_constructorArguments[serializerAndArgIndex.Item2] = value;
return(true);
}
SerializableJsonProperty property;
if (_serializablePropertiesMap.TryGetValue(propertyName, out property))
{
var value = property.ReadValue(reader, info, path + "." + propertyName);
_setPropertyValueActions.Add(instance => property.SetValue(instance, value));
return(true);
}
return(false);
}
private object DeserializeJsonArray(JsonReader reader, IJsonSerializeOperationInfo info, string path)
{
var jsonArray = new JsonArray(info);
if (reader.PeekContent() == JsonNodeType.CloseArray)
{
// If the next content node is CloseArray, we're reading an empty
// array. Read the CloseArray node and return the empty array.
reader.Read(path);
return(jsonArray);
}
var index = 0;
while (true)
{
jsonArray.Add(DeserializeObject(reader, info, path + "[" + index++ + "]"));
if (!reader.ReadContent(path))
{
throw new MalformedDocumentException(MalformedDocumentError.ArrayMissingCommaOrCloseSquareBracket,
path, reader.Line, reader.Position);
}
if (reader.NodeType == JsonNodeType.CloseArray)
{
break;
}
if (reader.NodeType != JsonNodeType.ItemSeparator)
{
throw new MalformedDocumentException(MalformedDocumentError.ArrayMissingCommaOrCloseSquareBracket,
path, reader.Line, reader.Position);
}
}
return(jsonArray);
}
public void SerializeObject(JsonWriter writer, object instance, IJsonSerializeOperationInfo info)
{
if (instance == null)
{
writer.WriteNull();
}
else
{
if (_encrypt)
{
var toggler = new EncryptWritesToggler(writer);
toggler.Toggle();
_write(writer, instance);
toggler.Revert();
}
else
{
_write(writer, instance);
}
}
}
public void SerializeObject(JsonWriter writer, object instance, IJsonSerializeOperationInfo info)
{
if (instance == null)
{
writer.WriteNull();
}
else
{
if (_encrypt)
{
var toggler = new EncryptWritesToggler(writer);
toggler.Toggle();
writer.WriteValue((bool)instance);
toggler.Revert();
}
else
{
writer.WriteValue((bool)instance);
}
}
}
private void Write(JsonWriter writer, object instance, IJsonSerializeOperationInfo info)
{
writer.WriteOpenObject();
var first = true;
var serializingProperties = _serializingPropertiesMap.GetOrAdd(instance.GetType(), GetSerializableProperties);
foreach (var property in serializingProperties)
{
if (first)
{
first = false;
}
else
{
writer.WriteItemSeparator();
}
property.WriteValue(writer, instance, info);
}
writer.WriteCloseObject();
}
public object DeserializeObject(JsonReader reader, IJsonSerializeOperationInfo info)
{
if (!reader.ReadContent())
{
throw new XSerializerException("Reached end of stream while parsing boolean value.");
}
if (_encrypt)
{
var toggler = new DecryptReadsToggler(reader);
toggler.Toggle();
try
{
return(Read(reader));
}
finally
{
toggler.Revert();
}
}
return(Read(reader));
}
public void SerializeObject(JsonWriter writer, object instance, IJsonSerializeOperationInfo info)
{
var jsonArray = (JsonArray)instance;
writer.WriteOpenArray();
var first = true;
foreach (var item in jsonArray)
{
if (first)
{
first = false;
}
else
{
writer.WriteItemSeparator();
}
_dynamicJsonSerializer.SerializeObject(writer, item, info);
}
writer.WriteCloseArray();
}
private void Write(JsonWriter writer, object instance, IJsonSerializeOperationInfo info)
{
writer.WriteOpenArray();
var enumerable = (IEnumerable)instance;
var first = true;
foreach (var item in enumerable)
{
if (first)
{
first = false;
}
else
{
writer.WriteItemSeparator();
}
_itemSerializer.SerializeObject(writer, item, info);
}
writer.WriteCloseArray();
}
private void Write(JsonWriter writer, object instance, IJsonSerializeOperationInfo info)
{
writer.WriteOpenArray();
var enumerable = (IEnumerable)instance;
var first = true;
foreach (var item in enumerable)
{
if (first)
{
first = false;
}
else
{
writer.WriteItemSeparator();
}
_itemSerializer.SerializeObject(writer, item, info);
}
writer.WriteCloseArray();
}
public object DeserializeObject(JsonReader reader, IJsonSerializeOperationInfo info)
{
if (!reader.ReadContent())
{
throw new XSerializerException("Reached end of stream while parsing string value.");
}
if (_encrypt)
{
var toggler = new DecryptReadsToggler(reader);
toggler.Toggle();
try
{
return Read(reader, info);
}
finally
{
toggler.Revert();
}
}
return Read(reader, info);
}
public object DeserializeObject(JsonReader reader, IJsonSerializeOperationInfo info, string path)
{
throw new NotImplementedException();
}
public void SerializeObject(JsonWriter writer, object instance, IJsonSerializeOperationInfo info)
{
var jsonArray = (JsonArray)instance;
writer.WriteOpenArray();
var first = true;
foreach (var item in jsonArray)
{
if (first)
{
first = false;
}
else
{
writer.WriteItemSeparator();
}
_dynamicJsonSerializer.SerializeObject(writer, item, info);
}
writer.WriteCloseArray();
}
private object Read(JsonReader reader, IJsonSerializeOperationInfo info, string path)
{
switch (reader.NodeType)
{
case JsonNodeType.Null:
case JsonNodeType.String:
case JsonNodeType.Boolean:
return reader.Value;
case JsonNodeType.Number:
try
{
return new JsonNumber((string)reader.Value);
}
catch (ArgumentException ex)
{
throw new MalformedDocumentException(MalformedDocumentError.InvalidValue,
path, reader.Value, reader.Line, reader.Position, ex);
}
case JsonNodeType.OpenObject:
return DeserializeJsonObject(reader, info, path);
case JsonNodeType.OpenArray:
return DeserializeJsonArray(reader, info, path);
case JsonNodeType.EndOfString:
throw new MalformedDocumentException(MalformedDocumentError.MissingValue,
path, reader.Line, reader.Position);
default:
throw new MalformedDocumentException(MalformedDocumentError.InvalidValue,
path, reader.Value, reader.Line, reader.Position);
}
}
private object DeserializeJsonObject(JsonReader reader, IJsonSerializeOperationInfo info, string path)
{
var jsonObject = new JsonObject(info);
foreach (var propertyName in reader.ReadProperties(path))
{
jsonObject.Add(propertyName, DeserializeObject(reader, info, path.AppendProperty(propertyName)));
}
return jsonObject;
}
private object DeserializeJsonArray(JsonReader reader, IJsonSerializeOperationInfo info, string path)
{
var jsonArray = new JsonArray(info);
if (reader.PeekContent() == JsonNodeType.CloseArray)
{
// If the next content node is CloseArray, we're reading an empty
// array. Read the CloseArray node and return the empty array.
reader.Read(path);
return jsonArray;
}
var index = 0;
while (true)
{
jsonArray.Add(DeserializeObject(reader, info, path + "[" + index++ + "]"));
if (!reader.ReadContent(path))
{
throw new MalformedDocumentException(MalformedDocumentError.ArrayMissingCommaOrCloseSquareBracket,
path, reader.Line, reader.Position);
}
if (reader.NodeType == JsonNodeType.CloseArray)
{
break;
}
if (reader.NodeType != JsonNodeType.ItemSeparator)
{
throw new MalformedDocumentException(MalformedDocumentError.ArrayMissingCommaOrCloseSquareBracket,
path, reader.Line, reader.Position);
}
}
return jsonArray;
}
private void WriteIDictionaryOfStringToObject(JsonWriter writer, object instance, IJsonSerializeOperationInfo info)
{
writer.WriteOpenObject();
var dictionary = (IDictionary<string, object>)instance;
var first = true;
foreach (var item in dictionary)
{
if (first)
{
first = false;
}
else
{
writer.WriteItemSeparator();
}
writer.WriteValue(item.Key);
writer.WriteNameValueSeparator();
_valueSerializer.SerializeObject(writer, item.Value, info);
}
writer.WriteCloseObject();
}
private object Read(JsonReader reader, IJsonSerializeOperationInfo info)
{
var factory = _createObjectFactory.Value.Invoke();
foreach (var propertyName in reader.ReadProperties())
{
if (!factory.SetValue(reader, propertyName, info))
{
reader.Discard();
}
}
return factory.GetInstance();
}
public void WriteValue(JsonWriter writer, object instance, IJsonSerializeOperationInfo info)
{
var value = _getValue(instance);
writer.WriteValue(Name);
writer.WriteNameValueSeparator();
_serializer.Value.SerializeObject(writer, value, info);
}
private void WriteIDictionaryOfAnythingToAnything(JsonWriter writer, object instance, IJsonSerializeOperationInfo info)
{
writer.WriteOpenObject();
var dictionary = (IEnumerable)instance;
var first = true;
Func <object, object> getKeyFunc = null;
Func <object, object> getValueFunc = null;
foreach (var item in dictionary)
{
if (first)
{
first = false;
var itemType = item.GetType();
getKeyFunc = _getKeyFuncCache.GetOrAdd(itemType, GetGetKeyFunc);
getValueFunc = _getValueFuncCache.GetOrAdd(itemType, GetGetValueFunc);
}
else
{
writer.WriteItemSeparator();
}
var key = getKeyFunc(item);
var keyString = key as string;
if (keyString != null)
{
writer.WriteValue(keyString);
}
else
{
var sb = new StringBuilder();
using (var stringWriter = new StringWriterWithEncoding(sb, Encoding.UTF8))
{
using (var keyWriter = new JsonWriter(stringWriter, info))
{
_keySerializer.SerializeObject(keyWriter, key, info);
}
}
writer.WriteValue((sb.ToString()));
}
writer.WriteNameValueSeparator();
_valueSerializer.SerializeObject(writer, getValueFunc(item), info);
}
writer.WriteCloseObject();
}
public object DeserializeObject(JsonReader reader, IJsonSerializeOperationInfo info)
{
if (!reader.ReadContent())
{
throw new XSerializerException("Unexpected end of input while attempting to parse '{' character.");
}
if (reader.NodeType == JsonNodeType.Null)
{
return null;
}
if (_encrypt)
{
var toggler = new DecryptReadsToggler(reader);
toggler.Toggle();
try
{
return Read(reader, info);
}
finally
{
toggler.Revert();
}
}
return Read(reader, info);
}
private object Read(JsonReader reader, IJsonSerializeOperationInfo info)
{
var dictionary = _createDictionary();
foreach (var keyString in reader.ReadProperties())
{
var key = _deserializeKey(keyString, info);
var value = _valueSerializer.DeserializeObject(reader, info);
var jsonNumber = value as JsonNumber;
if (jsonNumber != null)
{
value = jsonNumber.DoubleValue;
}
_addToDictionary(dictionary, key, value);
}
return dictionary;
}
public void SerializeObject(JsonWriter writer, object instance, IJsonSerializeOperationInfo info)
{
var jsonObject = (JsonObject)instance;
writer.WriteOpenObject();
var first = true;
foreach (var item in jsonObject)
{
if (first)
{
first = false;
}
else
{
writer.WriteItemSeparator();
}
writer.WriteValue(item.Key);
writer.WriteNameValueSeparator();
_dynamicJsonSerializer.SerializeObject(writer, item.Value, info);
}
writer.WriteCloseObject();
}
public object ReadValue(JsonReader reader, IJsonSerializeOperationInfo info, string path)
{
return _serializer.Value.DeserializeObject(reader, info, path);
}
private void WriteIDictionaryOfAnythingToAnything(JsonWriter writer, object instance, IJsonSerializeOperationInfo info)
{
writer.WriteOpenObject();
var dictionary = (IEnumerable)instance;
var first = true;
Func<object, object> getKeyFunc = null;
Func<object, object> getValueFunc = null;
foreach (var item in dictionary)
{
if (first)
{
first = false;
var itemType = item.GetType();
getKeyFunc = _getKeyFuncCache.GetOrAdd(itemType, GetGetKeyFunc);
getValueFunc = _getValueFuncCache.GetOrAdd(itemType, GetGetValueFunc);
}
else
{
writer.WriteItemSeparator();
}
var key = getKeyFunc(item);
var keyString = key as string;
if (keyString != null)
{
writer.WriteValue(keyString);
}
else
{
var sb = new StringBuilder();
using (var stringWriter = new StringWriterWithEncoding(sb, Encoding.UTF8))
{
using (var keyWriter = new JsonWriter(stringWriter, info))
{
_keySerializer.SerializeObject(keyWriter, key, info);
}
}
writer.WriteValue((sb.ToString()));
}
writer.WriteNameValueSeparator();
_valueSerializer.SerializeObject(writer, getValueFunc(item), info);
}
writer.WriteCloseObject();
}
public JsonReader(TextReader reader, IJsonSerializeOperationInfo info)
{
_primaryReader = reader;
_currentReader = _primaryReader;
_info = info;
}
public void SetValue(object instance, JsonReader reader, IJsonSerializeOperationInfo info, string path)
{
var value = ReadValue(reader, info, path);
_setValue(instance, value);
}
public JsonWriter(TextWriter writer, IJsonSerializeOperationInfo info)
{
_primaryWriter = writer;
_currentWriter = _primaryWriter;
_info = info;
}
private object Read(JsonReader reader, IJsonSerializeOperationInfo info, string path)
{
var factory = _createObjectFactory.Value.Invoke();
foreach (var propertyName in reader.ReadProperties(path))
{
var propertyPath = path.AppendProperty(propertyName);
if (!factory.SetValue(reader, propertyName, info, propertyPath))
{
reader.Discard(propertyPath);
}
}
return factory.GetInstance();
}
private void WriteIDictionaryOfStringToAnything(JsonWriter writer, object instance, IJsonSerializeOperationInfo info)
{
writer.WriteOpenObject();
var dictionary = (IEnumerable)instance;
var first = true;
Func<object, object> getKeyFunc = null;
Func<object, object> getValueFunc = null;
foreach (var item in dictionary)
{
if (first)
{
first = false;
var itemType = item.GetType();
getKeyFunc = _getKeyFuncCache.GetOrAdd(itemType, GetGetKeyFunc);
getValueFunc = _getValueFuncCache.GetOrAdd(itemType, GetGetValueFunc);
}
else
{
writer.WriteItemSeparator();
}
writer.WriteValue((string)getKeyFunc(item));
writer.WriteNameValueSeparator();
_valueSerializer.SerializeObject(writer, getValueFunc(item), info);
}
writer.WriteCloseObject();
}
public void SerializeObject(JsonWriter writer, object instance, IJsonSerializeOperationInfo info)
{
_write(writer, instance, info);
}
private void Write(JsonWriter writer, object instance, IJsonSerializeOperationInfo info)
{
writer.WriteOpenObject();
var first = true;
var serializingProperties = _serializingPropertiesMap.GetOrAdd(instance.GetType(), GetSerializableProperties);
foreach (var property in serializingProperties)
{
if (first)
{
first = false;
}
else
{
writer.WriteItemSeparator();
}
property.WriteValue(writer, instance, info);
}
writer.WriteCloseObject();
}
public bool SetValue(JsonReader reader, string propertyName, IJsonSerializeOperationInfo info, string path)
{
SerializableJsonProperty property;
if (_serializablePropertiesMap.TryGetValue(propertyName, out property))
{
property.SetValue(_instance, reader, info, path);
return true;
}
return false;
}
public bool SetValue(JsonReader reader, string propertyName, IJsonSerializeOperationInfo info, string path)
{
var serializerAndArgIndex = _getSerializerAndArgIndex(propertyName);
if (serializerAndArgIndex != null)
{
var value = serializerAndArgIndex.Item1.DeserializeObject(reader, info, path + "." + propertyName);
_constructorArguments[serializerAndArgIndex.Item2] = value;
return true;
}
SerializableJsonProperty property;
if (_serializablePropertiesMap.TryGetValue(propertyName, out property))
{
var value = property.ReadValue(reader, info, path + "." + propertyName);
_setPropertyValueActions.Add(instance => property.SetValue(instance, value));
return true;
}
return false;
}
private object Read(JsonReader reader, IJsonSerializeOperationInfo info, string path)
{
if (reader.NodeType == JsonNodeType.Null)
{
return null;
}
var list = _createList();
if (reader.PeekContent() == JsonNodeType.CloseArray)
{
// If the next content node is CloseArray, we're reading an empty
// array. Read the CloseArray node and return the empty list.
reader.Read(path);
return _transformList(list);
}
var index = 0;
while (true)
{
var item = _itemSerializer.DeserializeObject(reader, info, path + "[" + index++ + "]");
_addItem(list, item);
if (!reader.ReadContent(path))
{
Debug.Assert(reader.NodeType == JsonNodeType.EndOfString);
throw new MalformedDocumentException(MalformedDocumentError.ArrayMissingCommaOrCloseSquareBracket,
path, reader.Line, reader.Position);
}
if (reader.NodeType == JsonNodeType.CloseArray)
{
break;
}
if (reader.NodeType != JsonNodeType.ItemSeparator)
{
throw new MalformedDocumentException(MalformedDocumentError.ArrayMissingCommaOrCloseSquareBracket,
path, reader.Value, reader.Line, reader.Position);
}
}
return _transformList(list);
}
public void SerializeObject(JsonWriter writer, object instance, IJsonSerializeOperationInfo info)
{
_write(writer, instance, info);
}
