private void SerializeValue(JsonWriter writer, object value, JsonContract valueContract, JsonProperty member, JsonContainerContract collectionContract, JsonContract collectionValueContract)
{
if (value == null)
{
writer.WriteNull();
return;
}
JsonConverter converter;
if ((((converter = (member != null) ? member.Converter : null) != null) ||
((converter = (collectionContract != null) ? collectionContract.ItemConverter : null) != null) ||
((converter = valueContract.Converter) != null) ||
((converter = Serializer.GetMatchingConverter(valueContract.UnderlyingType)) != null) ||
((converter = valueContract.InternalConverter) != null)) &&
converter.CanWrite)
{
SerializeConvertable(writer, converter, value, valueContract, collectionContract, collectionValueContract);
return;
}
switch (valueContract.ContractType)
{
case JsonContractType.Object:
SerializeObject(writer, value, (JsonObjectContract)valueContract, member, collectionContract, collectionValueContract);
break;
case JsonContractType.Array:
JsonArrayContract arrayContract = (JsonArrayContract)valueContract;
SerializeList(writer, arrayContract.CreateWrapper(value), arrayContract, member, collectionContract, collectionValueContract);
break;
case JsonContractType.Primitive:
SerializePrimitive(writer, value, (JsonPrimitiveContract)valueContract, member, collectionContract, collectionValueContract);
break;
case JsonContractType.String:
SerializeString(writer, value, (JsonStringContract)valueContract);
break;
case JsonContractType.Dictionary:
JsonDictionaryContract dictionaryContract = (JsonDictionaryContract)valueContract;
SerializeDictionary(writer, dictionaryContract.CreateWrapper(value), dictionaryContract, member, collectionContract, collectionValueContract);
break;
#if !(NET35 || NET20 || WINDOWS_PHONE || PORTABLE)
case JsonContractType.Dynamic:
SerializeDynamic(writer, (IDynamicMetaObjectProvider)value, (JsonDynamicContract)valueContract, member, collectionContract, collectionValueContract);
break;
#endif
#if !(SILVERLIGHT || NETFX_CORE || PORTABLE)
case JsonContractType.Serializable:
SerializeISerializable(writer, (ISerializable)value, (JsonISerializableContract)valueContract, member, collectionContract, collectionValueContract);
break;
#endif
case JsonContractType.Linq:
((JToken)value).WriteTo(writer, (Serializer.Converters != null) ? Serializer.Converters.ToArray() : null);
break;
}
}
private object CreateAndPopulateDictionary(JsonReader reader, JsonDictionaryContract contract, string id)
{
IWrappedDictionary dictionary = contract.CreateWrapper(contract.DefaultCreator());
PopulateDictionary(dictionary, reader, contract, id);
return(dictionary.UnderlyingDictionary);
}
protected virtual JsonDictionaryContract CreateDictionaryContract(Type objectType)
{
JsonDictionaryContract jsonDictionaryContract = new JsonDictionaryContract(objectType);
this.InitializeContract(jsonDictionaryContract);
jsonDictionaryContract.PropertyNameResolver = new Func <string, string>(this.ResolvePropertyName);
return(jsonDictionaryContract);
}
protected virtual JsonDictionaryContract CreateDictionaryContract(Type objectType)
{
JsonDictionaryContract contract = new JsonDictionaryContract(objectType);
this.method_7(contract);
contract.PropertyNameResolver = new Func <string, string>(this.ResolvePropertyName);
return(contract);
}
/// <summary>
/// Creates a <see cref="JsonDictionaryContract"/> for the given type.
/// </summary>
/// <param name="objectType">Type of the object.</param>
/// <returns>A <see cref="JsonDictionaryContract"/> for the given type.</returns>
protected virtual JsonDictionaryContract CreateDictionaryContract(Type objectType)
{
JsonDictionaryContract contract = new JsonDictionaryContract(objectType);
InitializeContract(contract);
return(contract);
}
protected virtual JsonDictionaryContract CreateDictionaryContract(Type objectType)
{
JsonDictionaryContract jsonDictionaryContract = new JsonDictionaryContract(objectType);
InitializeContract(jsonDictionaryContract);
jsonDictionaryContract.PropertyNameResolver = ResolvePropertyName;
return(jsonDictionaryContract);
}
private object CreateAndPopulateDictionary(JsonReader reader, JsonDictionaryContract contract, string id)
{
IWrappedDictionary dictionary = CollectionUtils.CreateDictionaryWrapper(Activator.CreateInstance(contract.DictionaryTypeToCreate));
PopulateDictionary(dictionary, reader, contract, id);
return(dictionary.UnderlyingDictionary);
}
private void SerializeValue(JsonWriter writer, object value, JsonContract valueContract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
{
if (value == null)
{
writer.WriteNull();
}
else
{
JsonConverter converter;
if (((converter = member != null ? member.Converter : (JsonConverter)null) != null || (converter = containerProperty != null ? containerProperty.ItemConverter : (JsonConverter)null) != null || ((converter = containerContract != null ? containerContract.ItemConverter : (JsonConverter)null) != null || (converter = valueContract.Converter) != null || ((converter = this.Serializer.GetMatchingConverter(valueContract.UnderlyingType)) != null || (converter = valueContract.InternalConverter) != null))) && converter.CanWrite)
{
this.SerializeConvertable(writer, converter, value, valueContract, containerContract, containerProperty);
}
else
{
switch (valueContract.ContractType)
{
case JsonContractType.Object:
this.SerializeObject(writer, value, (JsonObjectContract)valueContract, member, containerContract, containerProperty);
break;
case JsonContractType.Array:
JsonArrayContract contract1 = (JsonArrayContract)valueContract;
if (!contract1.IsMultidimensionalArray)
{
this.SerializeList(writer, contract1.CreateWrapper(value), contract1, member, containerContract, containerProperty);
break;
}
else
{
this.SerializeMultidimensionalArray(writer, (Array)value, contract1, member, containerContract, containerProperty);
break;
}
case JsonContractType.Primitive:
this.SerializePrimitive(writer, value, (JsonPrimitiveContract)valueContract, member, containerContract, containerProperty);
break;
case JsonContractType.String:
this.SerializeString(writer, value, (JsonStringContract)valueContract);
break;
case JsonContractType.Dictionary:
JsonDictionaryContract contract2 = (JsonDictionaryContract)valueContract;
this.SerializeDictionary(writer, contract2.CreateWrapper(value), contract2, member, containerContract, containerProperty);
break;
case JsonContractType.Serializable:
this.SerializeISerializable(writer, (ISerializable)value, (JsonISerializableContract)valueContract, member, containerContract, containerProperty);
break;
case JsonContractType.Linq:
((JToken)value).WriteTo(writer, this.Serializer.Converters != null ? Enumerable.ToArray <JsonConverter>((IEnumerable <JsonConverter>) this.Serializer.Converters) : (JsonConverter[])null);
break;
}
}
}
}
private void SerializeValue(JsonWriter writer, object value, JsonContract valueContract, JsonProperty member, JsonContract collectionValueContract)
{
JsonConverter converter = (member != null) ? member.Converter : null;
if (value == null)
{
writer.WriteNull();
return;
}
if ((converter != null ||
((converter = valueContract.Converter) != null) ||
((converter = Serializer.GetMatchingConverter(valueContract.UnderlyingType)) != null) ||
((converter = valueContract.InternalConverter) != null)) &&
converter.CanWrite)
{
SerializeConvertable(writer, converter, value, valueContract);
}
else if (valueContract is JsonPrimitiveContract)
{
SerializePrimitive(writer, value, (JsonPrimitiveContract)valueContract, member, collectionValueContract);
}
else if (valueContract is JsonStringContract)
{
SerializeString(writer, value, (JsonStringContract)valueContract);
}
else if (valueContract is JsonObjectContract)
{
SerializeObject(writer, value, (JsonObjectContract)valueContract, member, collectionValueContract);
}
else if (valueContract is JsonDictionaryContract)
{
JsonDictionaryContract dictionaryContract = (JsonDictionaryContract)valueContract;
SerializeDictionary(writer, dictionaryContract.CreateWrapper(value), dictionaryContract, member, collectionValueContract);
}
else if (valueContract is JsonArrayContract)
{
JsonArrayContract arrayContract = (JsonArrayContract)valueContract;
if (!arrayContract.IsMultidimensionalArray)
{
SerializeList(writer, arrayContract.CreateWrapper(value), arrayContract, member, collectionValueContract);
}
else
{
SerializeMultidimensionalArray(writer, (Array)value, arrayContract, member, collectionValueContract);
}
}
else if (valueContract is JsonLinqContract)
{
((JToken)value).WriteTo(writer, (Serializer.Converters != null) ? Serializer.Converters.ToArray() : null);
}
#if !((UNITY_WINRT && !UNITY_EDITOR) || (UNITY_WP8 || UNITY_WP_8_1))
else if (valueContract is JsonISerializableContract)
{
SerializeISerializable(writer, (ISerializable)value, (JsonISerializableContract)valueContract);
}
#endif
}
private void SerializeValue(JsonWriter writer, object value, JsonContract valueContract, JsonProperty member, JsonContract collectionValueContract)
{
JsonConverter converter = (member != null) ? member.Converter : null;
if (value == null)
{
writer.WriteNull();
return;
}
if ((converter != null ||
((converter = valueContract.Converter) != null) ||
((converter = Serializer.GetMatchingConverter(valueContract.UnderlyingType)) != null) ||
((converter = valueContract.InternalConverter) != null)) &&
converter.CanWrite)
{
SerializeConvertable(writer, converter, value, valueContract);
}
else if (valueContract is JsonPrimitiveContract)
{
writer.WriteValue(value);
}
else if (valueContract is JsonStringContract)
{
SerializeString(writer, value, (JsonStringContract)valueContract);
}
else if (valueContract is JsonObjectContract)
{
SerializeObject(writer, value, (JsonObjectContract)valueContract, member, collectionValueContract);
}
else if (valueContract is JsonDictionaryContract)
{
JsonDictionaryContract dictionaryContract = (JsonDictionaryContract)valueContract;
SerializeDictionary(writer, dictionaryContract.CreateWrapper(value), dictionaryContract, member, collectionValueContract);
}
else if (valueContract is JsonArrayContract)
{
JsonArrayContract arrayContract = (JsonArrayContract)valueContract;
SerializeList(writer, arrayContract.CreateWrapper(value), arrayContract, member, collectionValueContract);
}
else if (valueContract is JsonLinqContract)
{
((JToken)value).WriteTo(writer, (Serializer.Converters != null) ? Serializer.Converters.ToArray() : null);
}
#if !SILVERLIGHT && !PocketPC
else if (valueContract is JsonISerializableContract)
{
SerializeISerializable(writer, (ISerializable)value, (JsonISerializableContract)valueContract);
}
#endif
#if !(NET35 || NET20 || WINDOWS_PHONE)
else if (valueContract is JsonDynamicContract)
{
SerializeDynamic(writer, (IDynamicMetaObjectProvider)value, (JsonDynamicContract)valueContract);
}
#endif
}
private void SerializeValue(JsonWriter writer, object value, JsonContract valueContract, JsonProperty member, JsonContract collectionValueContract)
{
JsonConverter converter = (member != null) ? member.Converter : null;
if (converter == null && JsonSerializerSettings.DefaultEnumSerializationHandling == EnumSerializationHandling.Name && value is Enum)
{
converter = new StringEnumConverter();
}
if (value == null)
{
writer.WriteNull();
return;
}
if ((converter != null ||
((converter = valueContract.Converter) != null) ||
((converter = Serializer.GetMatchingConverter(valueContract.UnderlyingType)) != null) ||
((converter = valueContract.InternalConverter) != null)) &&
converter.CanWrite)
{
SerializeConvertable(writer, converter, value, valueContract);
}
else if (valueContract is JsonPrimitiveContract)
{
SerializePrimitive(writer, value, (JsonPrimitiveContract)valueContract, member, collectionValueContract);
}
else if (valueContract is JsonStringContract)
{
SerializeString(writer, value, (JsonStringContract)valueContract);
}
else if (valueContract is JsonObjectContract)
{
SerializeObject(writer, value, (JsonObjectContract)valueContract, member, collectionValueContract);
}
else if (valueContract is JsonDictionaryContract)
{
JsonDictionaryContract dictionaryContract = (JsonDictionaryContract)valueContract;
SerializeDictionary(writer, dictionaryContract.CreateWrapper(value), dictionaryContract, member, collectionValueContract);
}
else if (valueContract is JsonArrayContract)
{
JsonArrayContract arrayContract = (JsonArrayContract)valueContract;
SerializeList(writer, arrayContract.CreateWrapper(value), arrayContract, member, collectionValueContract);
}
else if (valueContract is JsonLinqContract)
{
((JToken)value).WriteTo(writer, (Serializer.Converters != null) ? Serializer.Converters.ToArray() : null);
}
else if (valueContract is JsonISerializableContract)
{
SerializeISerializable(writer, (ISerializable)value, (JsonISerializableContract)valueContract);
}
}
private object CreateAndPopulateDictionary(JsonReader reader, JsonDictionaryContract contract, string id)
{
if (contract.DefaultCreator != null && (!contract.DefaultCreatorNonPublic || base.Serializer.ConstructorHandling == ConstructorHandling.AllowNonPublicDefaultConstructor))
{
object dictionary = contract.DefaultCreator();
IWrappedDictionary wrappedDictionary = contract.CreateWrapper(dictionary);
PopulateDictionary(wrappedDictionary, reader, contract, id);
return(wrappedDictionary.UnderlyingDictionary);
}
throw new JsonSerializationException("Unable to find a default constructor to use for type {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
}
private void SerializeValue(JsonWriter writer, object value, JsonContract valueContract, JsonProperty member, JsonContract collectionValueContract)
{
JsonConverter jsonConverter = (member == null) ? null : member.Converter;
if (value == null)
{
writer.WriteNull();
return;
}
if ((jsonConverter != null || (jsonConverter = valueContract.Converter) != null || (jsonConverter = base.Serializer.GetMatchingConverter(valueContract.UnderlyingType)) != null || (jsonConverter = valueContract.InternalConverter) != null) && jsonConverter.CanWrite)
{
this.SerializeConvertable(writer, jsonConverter, value, valueContract);
}
else if (valueContract is JsonPrimitiveContract)
{
this.SerializePrimitive(writer, value, (JsonPrimitiveContract)valueContract, member, collectionValueContract);
}
else if (valueContract is JsonStringContract)
{
this.SerializeString(writer, value, (JsonStringContract)valueContract);
}
else if (valueContract is JsonObjectContract)
{
this.SerializeObject(writer, value, (JsonObjectContract)valueContract, member, collectionValueContract);
}
else if (valueContract is JsonDictionaryContract)
{
JsonDictionaryContract jsonDictionaryContract = (JsonDictionaryContract)valueContract;
this.SerializeDictionary(writer, jsonDictionaryContract.CreateWrapper(value), jsonDictionaryContract, member, collectionValueContract);
}
else if (valueContract is JsonArrayContract)
{
JsonArrayContract jsonArrayContract = (JsonArrayContract)valueContract;
if (!jsonArrayContract.IsMultidimensionalArray)
{
this.SerializeList(writer, jsonArrayContract.CreateWrapper(value), jsonArrayContract, member, collectionValueContract);
}
else
{
this.SerializeMultidimensionalArray(writer, (Array)value, jsonArrayContract, member, collectionValueContract);
}
}
else if (valueContract is JsonLinqContract)
{
((JToken)value).WriteTo(writer, (base.Serializer.Converters == null) ? null : base.Serializer.Converters.ToArray <JsonConverter>());
}
else if (valueContract is JsonISerializableContract)
{
this.SerializeISerializable(writer, (ISerializable)value, (JsonISerializableContract)valueContract);
}
}
private void SerializeDictionary(JsonWriter writer, IDictionary values, JsonDictionaryContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
{
IWrappedDictionary wrappedDictionary = values as IWrappedDictionary;
object obj = (wrappedDictionary != null) ? wrappedDictionary.UnderlyingDictionary : values;
this.OnSerializing(writer, contract, obj);
this._serializeStack.Add(obj);
this.WriteObjectStart(writer, obj, contract, member, collectionContract, containerProperty);
if (contract.ItemContract == null)
{
contract.ItemContract = this.Serializer._contractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object));
}
if (contract.KeyContract == null)
{
contract.KeyContract = this.Serializer._contractResolver.ResolveContract(contract.DictionaryKeyType ?? typeof(object));
}
int top = writer.Top;
foreach (DictionaryEntry dictionaryEntry in values)
{
bool escape;
string text = this.GetPropertyName(writer, dictionaryEntry.Key, contract.KeyContract, out escape);
text = ((contract.PropertyNameResolver != null) ? contract.PropertyNameResolver(text) : text);
try
{
object value = dictionaryEntry.Value;
JsonContract jsonContract = contract.FinalItemContract ?? this.GetContractSafe(value);
if (this.ShouldWriteReference(value, null, jsonContract, contract, member))
{
writer.WritePropertyName(text, escape);
this.WriteReference(writer, value);
}
else if (this.CheckForCircularReference(writer, value, null, jsonContract, contract, member))
{
writer.WritePropertyName(text, escape);
this.SerializeValue(writer, value, jsonContract, null, contract, member);
}
}
catch (Exception ex)
{
if (!base.IsErrorHandled(obj, contract, text, null, writer.ContainerPath, ex))
{
throw;
}
this.HandleError(writer, top);
}
}
writer.WriteEndObject();
this._serializeStack.RemoveAt(this._serializeStack.Count - 1);
this.OnSerialized(writer, contract, obj);
}
private void SerializeDictionary(JsonWriter writer, IDictionary values, JsonDictionaryContract contract)
{
contract.InvokeOnSerializing(values);
SerializeStack.Add(values);
writer.WriteStartObject();
bool isReference = contract.IsReference ?? HasFlag(_serializer.PreserveReferencesHandling, PreserveReferencesHandling.Objects);
if (isReference)
{
writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
writer.WriteValue(_serializer.ReferenceResolver.GetReference(values));
}
if (HasFlag(_serializer.TypeNameHandling, TypeNameHandling.Objects))
{
WriteTypeProperty(writer, values.GetType());
}
foreach (DictionaryEntry entry in values)
{
string propertyName = entry.Key.ToString();
object value = entry.Value;
if (ShouldWriteReference(value, null))
{
writer.WritePropertyName(propertyName);
WriteReference(writer, value);
}
else
{
if (!CheckForCircularReference(value, null))
{
continue;
}
writer.WritePropertyName(propertyName);
SerializeValue(writer, value, null);
}
}
writer.WriteEndObject();
SerializeStack.RemoveAt(SerializeStack.Count - 1);
contract.InvokeOnSerialized(values);
}
private void SerializeDictionary(JsonWriter writer, IWrappedDictionary values, JsonDictionaryContract contract, JsonProperty member, JsonContract collectionValueContract)
{
contract.InvokeOnSerializing(values.UnderlyingDictionary, Serializer.Context);
SerializeStack.Add(values.UnderlyingDictionary);
writer.WriteStartObject();
bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Objects);
if (isReference)
{
writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
writer.WriteValue(Serializer.ReferenceResolver.GetReference(values.UnderlyingDictionary));
}
if (ShouldWriteType(TypeNameHandling.Objects, contract, member, collectionValueContract))
{
WriteTypeProperty(writer, values.UnderlyingDictionary.GetType());
}
JsonContract childValuesContract = Serializer.ContractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object));
int initialDepth = writer.Top;
// Mono Unity 3.0 fix
IDictionary d = values;
foreach (DictionaryEntry entry in d)
{
string propertyName = GetPropertyName(entry);
try
{
object value = entry.Value;
JsonContract valueContract = GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract))
{
writer.WritePropertyName(propertyName);
WriteReference(writer, value);
}
else
{
if (!CheckForCircularReference(value, null, contract))
continue;
writer.WritePropertyName(propertyName);
SerializeValue(writer, value, valueContract, null, childValuesContract);
}
}
catch (Exception ex)
{
if (IsErrorHandled(values.UnderlyingDictionary, contract, propertyName, ex))
HandleError(writer, initialDepth);
else
throw;
}
}
writer.WriteEndObject();
SerializeStack.RemoveAt(SerializeStack.Count - 1);
contract.InvokeOnSerialized(values.UnderlyingDictionary, Serializer.Context);
}
private void SerializeDictionary(JsonWriter writer, IDictionary values, JsonDictionaryContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
{
bool flag;
object underlyingDictionary;
IWrappedDictionary wrappedDictionaries = values as IWrappedDictionary;
if (wrappedDictionaries != null)
{
underlyingDictionary = wrappedDictionaries.UnderlyingDictionary;
}
else
{
underlyingDictionary = values;
}
object obj = underlyingDictionary;
this.OnSerializing(writer, contract, obj);
this._serializeStack.Add(obj);
this.WriteObjectStart(writer, obj, contract, member, collectionContract, containerProperty);
if (contract.ItemContract == null)
{
contract.ItemContract = this.Serializer._contractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object));
}
if (contract.KeyContract == null)
{
contract.KeyContract = this.Serializer._contractResolver.ResolveContract(contract.DictionaryKeyType ?? typeof(object));
}
int top = writer.Top;
IDictionaryEnumerator enumerator = values.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
DictionaryEntry entry = enumerator.Entry;
string propertyName = this.GetPropertyName(writer, entry.Key, contract.KeyContract, out flag);
propertyName = (contract.DictionaryKeyResolver != null ? contract.DictionaryKeyResolver(propertyName) : propertyName);
try
{
object value = entry.Value;
JsonContract finalItemContract = contract.FinalItemContract ?? this.GetContractSafe(value);
if (this.ShouldWriteReference(value, null, finalItemContract, contract, member))
{
writer.WritePropertyName(propertyName, flag);
this.WriteReference(writer, value);
}
else if (this.CheckForCircularReference(writer, value, null, finalItemContract, contract, member))
{
writer.WritePropertyName(propertyName, flag);
this.SerializeValue(writer, value, finalItemContract, null, contract, member);
}
else
{
continue;
}
}
catch (Exception exception)
{
if (!base.IsErrorHandled(obj, contract, propertyName, null, writer.ContainerPath, exception))
{
throw;
}
else
{
this.HandleError(writer, top);
}
}
}
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
else
{
}
}
writer.WriteEndObject();
this._serializeStack.RemoveAt(this._serializeStack.Count - 1);
this.OnSerialized(writer, contract, obj);
}
public object CreateNewDictionary(JsonReader reader, JsonDictionaryContract contract)
{
object dictionary;
if (contract.DefaultCreator != null &&
(!contract.DefaultCreatorNonPublic || Serializer.ConstructorHandling == ConstructorHandling.AllowNonPublicDefaultConstructor))
dictionary = contract.DefaultCreator();
else
throw JsonSerializationException.Create(reader, "Unable to find a default constructor to use for type {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
return dictionary;
}
/// <summary>
/// Creates a <see cref="JsonDictionaryContract"/> for the given type.
/// </summary>
/// <param name="objectType">Type of the object.</param>
/// <returns>A <see cref="JsonDictionaryContract"/> for the given type.</returns>
protected virtual JsonDictionaryContract CreateDictionaryContract(Type objectType)
{
JsonDictionaryContract contract = new JsonDictionaryContract(objectType);
InitializeContract(contract);
return contract;
}
private void SerializeDictionary(JsonWriter writer, IDictionary values, JsonDictionaryContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
{
IWrappedDictionary wrappedDictionary = values as IWrappedDictionary;
object underlyingDictionary = wrappedDictionary != null ? wrappedDictionary.UnderlyingDictionary : values;
OnSerializing(writer, contract, underlyingDictionary);
_serializeStack.Add(underlyingDictionary);
WriteObjectStart(writer, underlyingDictionary, contract, member, collectionContract, containerProperty);
if (contract.ItemContract == null)
contract.ItemContract = Serializer._contractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object));
if (contract.KeyContract == null)
contract.KeyContract = Serializer._contractResolver.ResolveContract(contract.DictionaryKeyType ?? typeof(object));
int initialDepth = writer.Top;
foreach (DictionaryEntry entry in values)
{
bool escape;
string propertyName = GetPropertyName(writer, entry.Key, contract.KeyContract, out escape);
propertyName = (contract.PropertyNameResolver != null)
? contract.PropertyNameResolver(propertyName)
: propertyName;
try
{
object value = entry.Value;
JsonContract valueContract = contract.FinalItemContract ?? GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract, contract, member))
{
writer.WritePropertyName(propertyName, escape);
WriteReference(writer, value);
}
else
{
if (!CheckForCircularReference(writer, value, null, valueContract, contract, member))
continue;
writer.WritePropertyName(propertyName, escape);
SerializeValue(writer, value, valueContract, null, contract, member);
}
}
catch (Exception ex)
{
if (IsErrorHandled(underlyingDictionary, contract, propertyName, null, writer.ContainerPath, ex))
HandleError(writer, initialDepth);
else
throw;
}
}
writer.WriteEndObject();
_serializeStack.RemoveAt(_serializeStack.Count - 1);
OnSerialized(writer, contract, underlyingDictionary);
}
private Schema CreateDictionarySchema(JsonDictionaryContract dictionaryContract)
{
var valueType = dictionaryContract.DictionaryValueType ?? typeof(object);
return new Schema
{
type = "object",
additionalProperties = CreateInlineSchema(valueType)
};
}
private object CreateObject(JsonReader reader, Type objectType, JsonContract contract, JsonProperty member, object existingValue)
{
CheckedRead(reader);
string id = null;
if (reader.TokenType == JsonToken.PropertyName)
{
bool specialProperty;
do
{
string propertyName = reader.Value.ToString();
if (string.Equals(propertyName, JsonTypeReflector.RefPropertyName, StringComparison.Ordinal))
{
CheckedRead(reader);
if (reader.TokenType != JsonToken.String)
{
throw new JsonSerializationException("JSON reference {0} property must have a string value.".FormatWith(CultureInfo.InvariantCulture, JsonTypeReflector.RefPropertyName));
}
string reference = reader.Value.ToString();
CheckedRead(reader);
if (reader.TokenType == JsonToken.PropertyName)
{
throw new JsonSerializationException("Additional content found in JSON reference object. A JSON reference object should only have a {0} property.".FormatWith(CultureInfo.InvariantCulture, JsonTypeReflector.RefPropertyName));
}
return(Serializer.ReferenceResolver.ResolveReference(reference));
}
else if (string.Equals(propertyName, JsonTypeReflector.TypePropertyName, StringComparison.Ordinal))
{
CheckedRead(reader);
string qualifiedTypeName = reader.Value.ToString();
CheckedRead(reader);
if ((((member != null) ? member.TypeNameHandling : null) ?? Serializer.TypeNameHandling) != TypeNameHandling.None)
{
string typeName;
string assemblyName;
ReflectionUtils.SplitFullyQualifiedTypeName(qualifiedTypeName, out typeName, out assemblyName);
Type specifiedType;
try
{
specifiedType = Serializer.Binder.BindToType(assemblyName, typeName);
}
catch (Exception ex)
{
throw new JsonSerializationException("Error resolving type specified in JSON '{0}'.".FormatWith(CultureInfo.InvariantCulture, qualifiedTypeName), ex);
}
if (specifiedType == null)
{
throw new JsonSerializationException("Type specified in JSON '{0}' was not resolved.".FormatWith(CultureInfo.InvariantCulture, qualifiedTypeName));
}
if (objectType != null && !objectType.IsAssignableFrom(specifiedType))
{
throw new JsonSerializationException("Type specified in JSON '{0}' is not compatible with '{1}'.".FormatWith(CultureInfo.InvariantCulture, specifiedType.AssemblyQualifiedName, objectType.AssemblyQualifiedName));
}
objectType = specifiedType;
contract = GetContractSafe(specifiedType);
}
specialProperty = true;
}
else if (string.Equals(propertyName, JsonTypeReflector.IdPropertyName, StringComparison.Ordinal))
{
CheckedRead(reader);
id = reader.Value.ToString();
CheckedRead(reader);
specialProperty = true;
}
else if (string.Equals(propertyName, JsonTypeReflector.ArrayValuesPropertyName, StringComparison.Ordinal))
{
CheckedRead(reader);
object list = CreateList(reader, objectType, contract, member, existingValue, id);
CheckedRead(reader);
return(list);
}
else
{
specialProperty = false;
}
} while (specialProperty &&
reader.TokenType == JsonToken.PropertyName);
}
if (!HasDefinedType(objectType))
{
return(CreateJObject(reader));
}
if (contract == null)
{
throw new JsonSerializationException("Could not resolve type '{0}' to a JsonContract.".FormatWith(CultureInfo.InvariantCulture, objectType));
}
JsonDictionaryContract dictionaryContract = contract as JsonDictionaryContract;
if (dictionaryContract != null)
{
if (existingValue == null)
{
return(CreateAndPopulateDictionary(reader, dictionaryContract, id));
}
return(PopulateDictionary(dictionaryContract.CreateWrapper(existingValue), reader, dictionaryContract, id));
}
JsonObjectContract objectContract = contract as JsonObjectContract;
if (objectContract != null)
{
if (existingValue == null)
{
return(CreateAndPopulateObject(reader, objectContract, id));
}
return(PopulateObject(existingValue, reader, objectContract, id));
}
#if !SILVERLIGHT && !PocketPC
JsonISerializableContract serializableContract = contract as JsonISerializableContract;
if (serializableContract != null)
{
return(CreateISerializable(reader, serializableContract, id));
}
#endif
#if !(NET35 || NET20 || SILVERLIGHT)
JsonDynamicContract dynamicContract = contract as JsonDynamicContract;
if (dynamicContract != null)
{
return(CreateDynamic(reader, dynamicContract, id));
}
#endif
throw new JsonSerializationException("Cannot deserialize JSON object into type '{0}'.".FormatWith(CultureInfo.InvariantCulture, objectType));
}
private IDictionary PopulateDictionary(IWrappedDictionary dictionary, JsonReader reader, JsonDictionaryContract contract, string id)
{
if (id != null)
{
Serializer.ReferenceResolver.AddReference(id, dictionary.UnderlyingDictionary);
}
contract.InvokeOnDeserializing(dictionary.UnderlyingDictionary);
int initialDepth = reader.Depth;
do
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
object keyValue = EnsureType(reader.Value, contract.DictionaryKeyType);
CheckedRead(reader);
try
{
dictionary.Add(keyValue, CreateValue(reader, contract.DictionaryValueType, GetContractSafe(contract.DictionaryValueType), null, null));
}
catch (Exception ex)
{
if (IsErrorHandled(dictionary, contract, keyValue, ex))
{
HandleError(reader, initialDepth);
}
else
{
throw;
}
}
break;
case JsonToken.EndObject:
contract.InvokeOnDeserialized(dictionary.UnderlyingDictionary);
return(dictionary);
default:
throw new JsonSerializationException("Unexpected token when deserializing object: " + reader.TokenType);
}
} while (reader.Read());
throw new JsonSerializationException("Unexpected end when deserializing object.");
}
private object CreateAndPopulateDictionary(JsonReader reader, JsonDictionaryContract contract, string id)
{
IWrappedDictionary dictionary = CollectionUtils.CreateDictionaryWrapper(Activator.CreateInstance(contract.DictionaryTypeToCreate));
PopulateDictionary(dictionary, reader, contract, id);
return dictionary.UnderlyingDictionary;
}
private void SerializeDictionary(JsonWriter writer, IDictionary values, JsonDictionaryContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
{
IWrappedDictionary wrappedDictionary = values as IWrappedDictionary;
object underlyingDictionary = wrappedDictionary != null ? wrappedDictionary.UnderlyingDictionary : values;
OnSerializing(writer, contract, underlyingDictionary);
_serializeStack.Add(underlyingDictionary);
WriteObjectStart(writer, underlyingDictionary, contract, member, collectionContract, containerProperty);
if (contract.ItemContract == null)
{
contract.ItemContract = Serializer._contractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object));
}
if (contract.KeyContract == null)
{
contract.KeyContract = Serializer._contractResolver.ResolveContract(contract.DictionaryKeyType ?? typeof(object));
}
int initialDepth = writer.Top;
// Manual use of IDictionaryEnumerator instead of foreach to avoid DictionaryEntry box allocations.
IDictionaryEnumerator e = values.GetEnumerator();
try
{
while (e.MoveNext())
{
DictionaryEntry entry = e.Entry;
bool escape;
string propertyName = GetPropertyName(writer, entry.Key, contract.KeyContract, out escape);
propertyName = (contract.DictionaryKeyResolver != null)
? contract.DictionaryKeyResolver(propertyName)
: propertyName;
try
{
object value = entry.Value;
JsonContract valueContract = contract.FinalItemContract ?? GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract, contract, member))
{
writer.WritePropertyName(propertyName, escape);
WriteReference(writer, value);
}
else
{
if (!CheckForCircularReference(writer, value, null, valueContract, contract, member))
{
continue;
}
writer.WritePropertyName(propertyName, escape);
SerializeValue(writer, value, valueContract, null, contract, member);
}
}
catch (Exception ex)
{
if (IsErrorHandled(underlyingDictionary, contract, propertyName, null, writer.ContainerPath, ex))
{
HandleError(writer, initialDepth);
}
else
{
throw;
}
}
}
}
finally
{
(e as IDisposable)?.Dispose();
}
writer.WriteEndObject();
_serializeStack.RemoveAt(_serializeStack.Count - 1);
OnSerialized(writer, contract, underlyingDictionary);
}
private object PopulateDictionary(IWrappedDictionary wrappedDictionary, JsonReader reader, JsonDictionaryContract contract, JsonProperty containerProperty, string id)
{
object underlyingDictionary = wrappedDictionary.UnderlyingDictionary;
if (id != null)
this.AddReference(reader, id, underlyingDictionary);
contract.InvokeOnDeserializing(underlyingDictionary, this.Serializer.Context);
int depth = reader.Depth;
if (contract.KeyContract == null)
contract.KeyContract = this.GetContractSafe(contract.DictionaryKeyType);
if (contract.ItemContract == null)
contract.ItemContract = this.GetContractSafe(contract.DictionaryValueType);
JsonConverter jsonConverter = contract.ItemConverter ?? this.GetConverter(contract.ItemContract, (JsonConverter) null, (JsonContainerContract) contract, containerProperty);
bool flag = false;
do
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
object keyValue = reader.Value;
try
{
try
{
keyValue = this.EnsureType(reader, keyValue, CultureInfo.InvariantCulture, contract.KeyContract, contract.DictionaryKeyType);
}
catch (Exception ex)
{
throw JsonSerializationException.Create(reader, StringUtils.FormatWith("Could not convert string '{0}' to dictionary key type '{1}'. Create a TypeConverter to convert from the string to the key type object.", (IFormatProvider) CultureInfo.InvariantCulture, reader.Value, (object) contract.DictionaryKeyType), ex);
}
if (!this.ReadForType(reader, contract.ItemContract, jsonConverter != null))
throw JsonSerializationException.Create(reader, "Unexpected end when deserializing object.");
object obj = jsonConverter == null || !jsonConverter.CanRead ? this.CreateValueInternal(reader, contract.DictionaryValueType, contract.ItemContract, (JsonProperty) null, (JsonContainerContract) contract, containerProperty, (object) null) : jsonConverter.ReadJson(reader, contract.DictionaryValueType, (object) null, (JsonSerializer) this.GetInternalSerializer());
wrappedDictionary[keyValue] = obj;
goto case JsonToken.Comment;
}
catch (Exception ex)
{
if (this.IsErrorHandled(underlyingDictionary, (JsonContract) contract, keyValue, reader.Path, ex))
{
this.HandleError(reader, true, depth);
goto case JsonToken.Comment;
}
else
throw;
}
case JsonToken.Comment:
continue;
case JsonToken.EndObject:
flag = true;
goto case JsonToken.Comment;
default:
throw JsonSerializationException.Create(reader, "Unexpected token when deserializing object: " + (object) reader.TokenType);
}
}
while (!flag && reader.Read());
if (!flag)
this.ThrowUnexpectedEndException(reader, (JsonContract) contract, underlyingDictionary, "Unexpected end when deserializing object.");
contract.InvokeOnDeserialized(underlyingDictionary, this.Serializer.Context);
return underlyingDictionary;
}
public object CreateNewDictionary(JsonReader reader, JsonDictionaryContract contract)
{
if (contract.DefaultCreator != null && (!contract.DefaultCreatorNonPublic || this.Serializer.ConstructorHandling == ConstructorHandling.AllowNonPublicDefaultConstructor))
return contract.DefaultCreator();
else
throw JsonSerializationException.Create(reader, StringUtils.FormatWith("Unable to find a default constructor to use for type {0}.", (IFormatProvider) CultureInfo.InvariantCulture, (object) contract.UnderlyingType));
}
public object CreateNewDictionary(JsonReader reader, JsonDictionaryContract contract, out bool isTemporaryDictionary)
{
object dictionary;
if (contract.DefaultCreator != null && (!contract.DefaultCreatorNonPublic || Serializer.ConstructorHandling == ConstructorHandling.AllowNonPublicDefaultConstructor))
{
dictionary = contract.DefaultCreator();
isTemporaryDictionary = false;
}
else if (contract.IsReadOnlyDictionary)
{
dictionary = contract.CreateTemporaryDictionary();
isTemporaryDictionary = true;
}
else
{
throw JsonSerializationException.Create(reader, "Unable to find a default constructor to use for type {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
}
return dictionary;
}
private IDictionary PopulateDictionary(IWrappedDictionary dictionary, JsonReader reader, JsonDictionaryContract contract, string id)
{
if (id != null)
_serializer.ReferenceResolver.AddReference(id, dictionary.UnderlyingDictionary);
contract.InvokeOnDeserializing(dictionary.UnderlyingDictionary);
do
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
object keyValue = EnsureType(reader.Value, contract.DictionaryKeyType);
CheckedRead(reader);
dictionary.Add(keyValue, CreateValue(reader, contract.DictionaryValueType, null, null));
break;
case JsonToken.EndObject:
contract.InvokeOnDeserialized(dictionary.UnderlyingDictionary);
return dictionary;
default:
throw new JsonSerializationException("Unexpected token when deserializing object: " + reader.TokenType);
}
} while (reader.Read());
throw new JsonSerializationException("Unexpected end when deserializing object.");
}
private void SerializeDictionary(JsonWriter writer, IWrappedDictionary values, JsonDictionaryContract contract, JsonProperty member, JsonContract collectionValueContract)
{
contract.InvokeOnSerializing(values.UnderlyingDictionary, Serializer.Context);
SerializeStack.Add(values.UnderlyingDictionary);
writer.WriteStartObject();
bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Objects);
if (isReference)
{
writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
writer.WriteValue(Serializer.ReferenceResolver.GetReference(this, values.UnderlyingDictionary));
}
if (ShouldWriteType(TypeNameHandling.Objects, contract, member, collectionValueContract))
{
WriteTypeProperty(writer, values.UnderlyingDictionary.GetType());
}
JsonContract childValuesContract = Serializer.ContractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object));
int initialDepth = writer.Top;
// Mono Unity 3.0 fix
IDictionary d = values;
foreach (DictionaryEntry entry in d)
{
string propertyName = GetPropertyName(entry);
propertyName = (contract.PropertyNameResolver != null)
? contract.PropertyNameResolver(propertyName)
: propertyName;
try
{
object value = entry.Value;
JsonContract valueContract = GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract))
{
writer.WritePropertyName(propertyName);
WriteReference(writer, value);
}
else
{
if (!CheckForCircularReference(value, null, contract))
{
continue;
}
writer.WritePropertyName(propertyName);
SerializeValue(writer, value, valueContract, null, childValuesContract);
}
}
catch (Exception ex)
{
if (IsErrorHandled(values.UnderlyingDictionary, contract, propertyName, ex))
{
HandleError(writer, initialDepth);
}
else
{
throw;
}
}
}
writer.WriteEndObject();
SerializeStack.RemoveAt(SerializeStack.Count - 1);
contract.InvokeOnSerialized(values.UnderlyingDictionary, Serializer.Context);
}
private void SerializeDictionary(JsonWriter writer, IDictionary values, JsonDictionaryContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
{
IWrappedDictionary wrappedDictionary = values as IWrappedDictionary;
object underlyingDictionary = wrappedDictionary != null ? wrappedDictionary.UnderlyingDictionary : values;
OnSerializing(writer, contract, underlyingDictionary);
_serializeStack.Add(underlyingDictionary);
WriteObjectStart(writer, underlyingDictionary, contract, member, collectionContract, containerProperty);
if (contract.ItemContract == null)
{
contract.ItemContract = Serializer._contractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object));
}
if (contract.KeyContract == null)
{
contract.KeyContract = Serializer._contractResolver.ResolveContract(contract.DictionaryKeyType ?? typeof(object));
}
int initialDepth = writer.Top;
foreach (DictionaryEntry entry in values)
{
bool escape;
string propertyName = GetPropertyName(writer, entry.Key, contract.KeyContract, out escape);
propertyName = (contract.DictionaryKeyResolver != null)
? contract.DictionaryKeyResolver(propertyName)
: propertyName;
try
{
object value = entry.Value;
JsonContract valueContract = contract.FinalItemContract ?? GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract, contract, member))
{
writer.WritePropertyName(propertyName, escape);
WriteReference(writer, value);
}
else
{
if (!CheckForCircularReference(writer, value, null, valueContract, contract, member))
{
continue;
}
writer.WritePropertyName(propertyName, escape);
SerializeValue(writer, value, valueContract, null, contract, member);
}
}
catch (Exception ex)
{
if (IsErrorHandled(underlyingDictionary, contract, propertyName, null, writer.ContainerPath, ex))
{
HandleError(writer, initialDepth);
}
else
{
throw;
}
}
}
writer.WriteEndObject();
_serializeStack.RemoveAt(_serializeStack.Count - 1);
OnSerialized(writer, contract, underlyingDictionary);
}
private object PopulateDictionary(IWrappedDictionary dictionary, JsonReader reader, JsonDictionaryContract contract, string id)
{
if (id != null)
Serializer.ReferenceResolver.AddReference(id, dictionary.UnderlyingDictionary);
contract.InvokeOnDeserializing(dictionary.UnderlyingDictionary, Serializer.Context);
int initialDepth = reader.Depth;
do
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
object keyValue = EnsureType(reader.Value, contract.DictionaryKeyType);
CheckedRead(reader);
try
{
dictionary[keyValue] = CreateValue(reader, contract.DictionaryValueType, GetContractSafe(contract.DictionaryValueType), null, null);
}
catch (Exception ex)
{
if (IsErrorHandled(dictionary, contract, keyValue, ex))
HandleError(reader, initialDepth);
else
throw;
}
break;
case JsonToken.EndObject:
contract.InvokeOnDeserialized(dictionary.UnderlyingDictionary, Serializer.Context);
return dictionary.UnderlyingDictionary;
default:
throw new JsonSerializationException("Unexpected token when deserializing object: " + reader.TokenType);
}
} while (reader.Read());
throw new JsonSerializationException("Unexpected end when deserializing object.");
}
private object PopulateDictionary(IDictionary dictionary, JsonReader reader, JsonDictionaryContract contract, JsonProperty containerProperty, string id)
{
IWrappedDictionary wrappedDictionary = dictionary as IWrappedDictionary;
object underlyingDictionary = wrappedDictionary != null ? wrappedDictionary.UnderlyingDictionary : dictionary;
if (id != null)
AddReference(reader, id, underlyingDictionary);
OnDeserializing(reader, contract, underlyingDictionary);
int initialDepth = reader.Depth;
if (contract.KeyContract == null)
contract.KeyContract = GetContractSafe(contract.DictionaryKeyType);
if (contract.ItemContract == null)
contract.ItemContract = GetContractSafe(contract.DictionaryValueType);
JsonConverter dictionaryValueConverter = contract.ItemConverter ?? GetConverter(contract.ItemContract, null, contract, containerProperty);
PrimitiveTypeCode keyTypeCode = (contract.KeyContract is JsonPrimitiveContract) ? ((JsonPrimitiveContract)contract.KeyContract).TypeCode : PrimitiveTypeCode.Empty;
bool finished = false;
do
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
object keyValue = reader.Value;
try
{
try
{
object dt;
// this is for correctly reading ISO and MS formatted dictionary keys
if ((keyTypeCode == PrimitiveTypeCode.DateTime || keyTypeCode == PrimitiveTypeCode.DateTimeNullable)
&& DateTimeUtils.TryParseDateTime(keyValue.ToString(), DateParseHandling.DateTime, reader.DateTimeZoneHandling, out dt))
{
keyValue = dt;
}
#if !NET20
else if ((keyTypeCode == PrimitiveTypeCode.DateTimeOffset || keyTypeCode == PrimitiveTypeCode.DateTimeOffsetNullable)
&& DateTimeUtils.TryParseDateTime(keyValue.ToString(), DateParseHandling.DateTimeOffset, reader.DateTimeZoneHandling, out dt))
{
keyValue = dt;
}
#endif
else
{
keyValue = EnsureType(reader, keyValue, CultureInfo.InvariantCulture, contract.KeyContract, contract.DictionaryKeyType);
}
}
catch (Exception ex)
{
throw JsonSerializationException.Create(reader, "Could not convert string '{0}' to dictionary key type '{1}'. Create a TypeConverter to convert from the string to the key type object.".FormatWith(CultureInfo.InvariantCulture, reader.Value, contract.DictionaryKeyType), ex);
}
if (!ReadForType(reader, contract.ItemContract, dictionaryValueConverter != null))
throw JsonSerializationException.Create(reader, "Unexpected end when deserializing object.");
object itemValue;
if (dictionaryValueConverter != null && dictionaryValueConverter.CanRead)
itemValue = DeserializeConvertable(dictionaryValueConverter, reader, contract.DictionaryValueType, null);
else
itemValue = CreateValueInternal(reader, contract.DictionaryValueType, contract.ItemContract, null, contract, containerProperty, null);
dictionary[keyValue] = itemValue;
}
catch (Exception ex)
{
if (IsErrorHandled(underlyingDictionary, contract, keyValue, reader as IJsonLineInfo, reader.Path, ex))
HandleError(reader, true, initialDepth);
else
throw;
}
break;
case JsonToken.Comment:
break;
case JsonToken.EndObject:
finished = true;
break;
default:
throw JsonSerializationException.Create(reader, "Unexpected token when deserializing object: " + reader.TokenType);
}
} while (!finished && reader.Read());
if (!finished)
ThrowUnexpectedEndException(reader, contract, underlyingDictionary, "Unexpected end when deserializing object.");
OnDeserialized(reader, contract, underlyingDictionary);
return underlyingDictionary;
}
private void SerializeDictionary(JsonWriter writer, IDictionary values, JsonDictionaryContract contract)
{
contract.InvokeOnSerializing(values);
SerializeStack.Add(values);
writer.WriteStartObject();
bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Objects);
if (isReference)
{
writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
writer.WriteValue(Serializer.ReferenceResolver.GetReference(values));
}
if (HasFlag(Serializer.TypeNameHandling, TypeNameHandling.Objects))
{
WriteTypeProperty(writer, values.GetType());
}
int initialDepth = writer.Top;
foreach (DictionaryEntry entry in values)
{
string propertyName = GetPropertyName(entry);
try
{
object value = entry.Value;
JsonContract valueContract = GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract))
{
writer.WritePropertyName(propertyName);
WriteReference(writer, value);
}
else
{
if (!CheckForCircularReference(value, null))
continue;
writer.WritePropertyName(propertyName);
SerializeValue(writer, value, null, valueContract);
}
}
catch (Exception ex)
{
if (IsErrorHandled(values, contract, propertyName, ex))
HandleError(writer, initialDepth);
else
throw;
}
}
writer.WriteEndObject();
SerializeStack.RemoveAt(SerializeStack.Count - 1);
contract.InvokeOnSerialized(values);
}
private Schema CreateDictionarySchema(JsonDictionaryContract dictionaryContract)
{
var keyType = dictionaryContract.DictionaryKeyType ?? typeof(object);
var valueType = dictionaryContract.DictionaryValueType ?? typeof(object);
if (keyType.IsEnum)
{
return new Schema
{
type = "object",
properties = Enum.GetNames(keyType).ToDictionary(
(name) => dictionaryContract.PropertyNameResolver(name),
(name) => CreateInlineSchema(valueType)
)
};
}
else
{
return new Schema
{
type = "object",
additionalProperties = CreateInlineSchema(valueType)
};
}
}
private void SerializeDictionary(JsonWriter writer, IWrappedDictionary values, JsonDictionaryContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
{
contract.InvokeOnSerializing(values.UnderlyingDictionary, this.Serializer.Context);
this._serializeStack.Add(values.UnderlyingDictionary);
this.WriteObjectStart(writer, values.UnderlyingDictionary, (JsonContract)contract, member, collectionContract, containerProperty);
if (contract.ItemContract == null)
{
contract.ItemContract = this.Serializer.ContractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object));
}
int top = writer.Top;
foreach (DictionaryEntry entry in (IDictionary)values)
{
string propertyName = this.GetPropertyName(entry);
string name = contract.PropertyNameResolver != null?contract.PropertyNameResolver(propertyName) : propertyName;
try
{
object obj = entry.Value;
JsonContract jsonContract = contract.FinalItemContract ?? this.GetContractSafe(obj);
if (this.ShouldWriteReference(obj, (JsonProperty)null, jsonContract, (JsonContainerContract)contract, member))
{
writer.WritePropertyName(name);
this.WriteReference(writer, obj);
}
else if (this.CheckForCircularReference(writer, obj, (JsonProperty)null, jsonContract, (JsonContainerContract)contract, member))
{
writer.WritePropertyName(name);
this.SerializeValue(writer, obj, jsonContract, (JsonProperty)null, (JsonContainerContract)contract, member);
}
}
catch (Exception ex)
{
if (this.IsErrorHandled(values.UnderlyingDictionary, (JsonContract)contract, (object)name, writer.ContainerPath, ex))
{
this.HandleError(writer, top);
}
else
{
throw;
}
}
}
writer.WriteEndObject();
this._serializeStack.RemoveAt(this._serializeStack.Count - 1);
contract.InvokeOnSerialized(values.UnderlyingDictionary, this.Serializer.Context);
}
private void SerializeValue(JsonWriter writer, object value, JsonContract valueContract, JsonProperty member, JsonContract collectionValueContract)
{
JsonConverter converter;
JsonConverter[] array;
if (member == null)
{
converter = null;
}
else
{
converter = member.Converter;
}
JsonConverter jsonConverter = converter;
if (value == null)
{
writer.WriteNull();
return;
}
if (jsonConverter == null)
{
JsonConverter converter1 = valueContract.Converter;
jsonConverter = converter1;
if (converter1 == null)
{
JsonConverter matchingConverter = base.Serializer.GetMatchingConverter(valueContract.UnderlyingType);
jsonConverter = matchingConverter;
if (matchingConverter == null)
{
JsonConverter internalConverter = valueContract.InternalConverter;
jsonConverter = internalConverter;
if (internalConverter == null)
{
goto Label0;
}
}
}
}
if (jsonConverter.CanWrite)
{
this.SerializeConvertable(writer, jsonConverter, value, valueContract);
return;
}
if (valueContract is JsonPrimitiveContract)
{
this.SerializePrimitive(writer, value, (JsonPrimitiveContract)valueContract, member, collectionValueContract);
}
else if (valueContract is JsonStringContract)
{
this.SerializeString(writer, value, (JsonStringContract)valueContract);
}
else if (valueContract is JsonObjectContract)
{
this.SerializeObject(writer, value, (JsonObjectContract)valueContract, member, collectionValueContract);
}
else if (valueContract is JsonDictionaryContract)
{
JsonDictionaryContract jsonDictionaryContract = (JsonDictionaryContract)valueContract;
this.SerializeDictionary(writer, jsonDictionaryContract.CreateWrapper(value), jsonDictionaryContract, member, collectionValueContract);
}
else if (valueContract is JsonArrayContract)
{
JsonArrayContract jsonArrayContract = (JsonArrayContract)valueContract;
if (jsonArrayContract.IsMultidimensionalArray)
{
this.SerializeMultidimensionalArray(writer, (Array)value, jsonArrayContract, member, collectionValueContract);
}
else
{
this.SerializeList(writer, jsonArrayContract.CreateWrapper(value), jsonArrayContract, member, collectionValueContract);
}
}
else if (valueContract is JsonLinqContract)
{
JToken jTokens = (JToken)value;
JsonWriter jsonWriter = writer;
if (base.Serializer.Converters == null)
{
array = null;
}
else
{
array = base.Serializer.Converters.ToArray <JsonConverter>();
}
jTokens.WriteTo(jsonWriter, array);
}
else if (valueContract is JsonISerializableContract)
{
this.SerializeISerializable(writer, (ISerializable)value, (JsonISerializableContract)valueContract);
}
}
private void SerializeDictionary(JsonWriter writer, IWrappedDictionary values, JsonDictionaryContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
{
contract.InvokeOnSerializing(values.UnderlyingDictionary, this.Serializer.Context);
this._serializeStack.Add(values.UnderlyingDictionary);
this.WriteObjectStart(writer, values.UnderlyingDictionary, (JsonContract) contract, member, collectionContract, containerProperty);
if (contract.ItemContract == null)
contract.ItemContract = this.Serializer.ContractResolver.ResolveContract(contract.DictionaryValueType ?? typeof (object));
int top = writer.Top;
foreach (DictionaryEntry entry in (IDictionary) values)
{
string propertyName = this.GetPropertyName(entry);
string name = contract.PropertyNameResolver != null ? contract.PropertyNameResolver(propertyName) : propertyName;
try
{
object obj = entry.Value;
JsonContract jsonContract = contract.FinalItemContract ?? this.GetContractSafe(obj);
if (this.ShouldWriteReference(obj, (JsonProperty) null, jsonContract, (JsonContainerContract) contract, member))
{
writer.WritePropertyName(name);
this.WriteReference(writer, obj);
}
else if (this.CheckForCircularReference(writer, obj, (JsonProperty) null, jsonContract, (JsonContainerContract) contract, member))
{
writer.WritePropertyName(name);
this.SerializeValue(writer, obj, jsonContract, (JsonProperty) null, (JsonContainerContract) contract, member);
}
}
catch (Exception ex)
{
if (this.IsErrorHandled(values.UnderlyingDictionary, (JsonContract) contract, (object) name, writer.ContainerPath, ex))
this.HandleError(writer, top);
else
throw;
}
}
writer.WriteEndObject();
this._serializeStack.RemoveAt(this._serializeStack.Count - 1);
contract.InvokeOnSerialized(values.UnderlyingDictionary, this.Serializer.Context);
}
private void SerializeDictionary(JsonWriter writer, IWrappedDictionary values, JsonDictionaryContract contract, JsonProperty member, JsonContract collectionValueContract)
{
contract.InvokeOnSerializing(values.UnderlyingDictionary, base.Serializer.Context);
SerializeStack.Add(values.UnderlyingDictionary);
writer.WriteStartObject();
bool?isReference = contract.IsReference;
if ((!isReference.HasValue) ? HasFlag(base.Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Objects) : isReference.Value)
{
writer.WritePropertyName("$id");
writer.WriteValue(base.Serializer.ReferenceResolver.GetReference(this, values.UnderlyingDictionary));
}
if (ShouldWriteType(TypeNameHandling.Objects, contract, member, collectionValueContract))
{
WriteTypeProperty(writer, values.UnderlyingDictionary.GetType());
}
JsonContract collectionValueContract2 = base.Serializer.ContractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object));
int top = writer.Top;
IDictionaryEnumerator enumerator = values.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
DictionaryEntry entry = (DictionaryEntry)enumerator.Current;
string propertyName = GetPropertyName(entry);
propertyName = ((contract.PropertyNameResolver == null) ? propertyName : contract.PropertyNameResolver(propertyName));
try
{
object value = entry.Value;
JsonContract contractSafe = GetContractSafe(value);
if (ShouldWriteReference(value, null, contractSafe))
{
writer.WritePropertyName(propertyName);
WriteReference(writer, value);
}
else if (CheckForCircularReference(value, null, contract))
{
writer.WritePropertyName(propertyName);
SerializeValue(writer, value, contractSafe, null, collectionValueContract2);
}
}
catch (Exception ex)
{
if (!IsErrorHandled(values.UnderlyingDictionary, contract, propertyName, ex))
{
throw;
}
HandleError(writer, top);
}
}
}
finally
{
(enumerator as IDisposable)?.Dispose();
}
writer.WriteEndObject();
SerializeStack.RemoveAt(SerializeStack.Count - 1);
contract.InvokeOnSerialized(values.UnderlyingDictionary, base.Serializer.Context);
}
private void SerializeValue(JsonWriter writer, object value, JsonContract valueContract, JsonProperty member, JsonContract collectionValueContract)
{
JsonConverter converter = (member != null) ? member.Converter : null;
if (value == null)
{
writer.WriteNull();
return;
}
if ((converter != null ||
((converter = valueContract.Converter) != null) ||
((converter = Serializer.GetMatchingConverter(valueContract.UnderlyingType)) != null) ||
((converter = valueContract.InternalConverter) != null)) &&
converter.CanWrite)
{
SerializeConvertable(writer, converter, value, valueContract);
}
else if (valueContract is JsonPrimitiveContract)
{
writer.WriteValue(value);
}
else if (valueContract is JsonStringContract)
{
SerializeString(writer, value, (JsonStringContract)valueContract);
}
else if (valueContract is JsonObjectContract)
{
SerializeObject(writer, value, (JsonObjectContract)valueContract, member, collectionValueContract);
}
else if (valueContract is JsonDictionaryContract)
{
JsonDictionaryContract dictionaryContract = (JsonDictionaryContract)valueContract;
SerializeDictionary(writer, dictionaryContract.CreateWrapper(value), dictionaryContract, member, collectionValueContract);
}
else if (valueContract is JsonArrayContract)
{
if (value is IList)
{
SerializeList(writer, (IList)value, (JsonArrayContract)valueContract, member, collectionValueContract);
}
else if (value is IEnumerable)
{
SerializeList(writer, ((IEnumerable)value).Cast <object>().ToList(), (JsonArrayContract)valueContract, member, collectionValueContract);
}
else
{
throw new Exception(
"Cannot serialize '{0}' into a JSON array. Type does not implement IEnumerable.".FormatWith(
CultureInfo.InvariantCulture, value.GetType()));
}
}
else if (valueContract is JsonLinqContract)
{
((JToken)value).WriteTo(writer, (Serializer.Converters != null) ? Serializer.Converters.ToArray() : null);
}
#if !SILVERLIGHT && !PocketPC
else if (valueContract is JsonISerializableContract)
{
SerializeISerializable(writer, (ISerializable)value, (JsonISerializableContract)valueContract);
}
#endif
}
private object PopulateDictionary(IWrappedDictionary wrappedDictionary, JsonReader reader, JsonDictionaryContract contract, JsonProperty containerProperty, string id)
{
object dictionary = wrappedDictionary.UnderlyingDictionary;
if (id != null)
AddReference(reader, id, dictionary);
OnDeserializing(reader, contract, dictionary);
int initialDepth = reader.Depth;
if (contract.KeyContract == null)
contract.KeyContract = GetContractSafe(contract.DictionaryKeyType);
if (contract.ItemContract == null)
contract.ItemContract = GetContractSafe(contract.DictionaryValueType);
JsonConverter dictionaryValueConverter = contract.ItemConverter ?? GetConverter(contract.ItemContract, null, contract, containerProperty);
bool finished = false;
do
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
object keyValue = reader.Value;
try
{
try
{
keyValue = EnsureType(reader, keyValue, CultureInfo.InvariantCulture, contract.KeyContract, contract.DictionaryKeyType);
}
catch (Exception ex)
{
throw JsonSerializationException.Create(reader, "Could not convert string '{0}' to dictionary key type '{1}'. Create a TypeConverter to convert from the string to the key type object.".FormatWith(CultureInfo.InvariantCulture, reader.Value, contract.DictionaryKeyType), ex);
}
if (!ReadForType(reader, contract.ItemContract, dictionaryValueConverter != null))
throw JsonSerializationException.Create(reader, "Unexpected end when deserializing object.");
object itemValue;
if (dictionaryValueConverter != null && dictionaryValueConverter.CanRead)
itemValue = DeserializeConvertable(dictionaryValueConverter, reader, contract.DictionaryValueType, null);
else
itemValue = CreateValueInternal(reader, contract.DictionaryValueType, contract.ItemContract, null, contract, containerProperty, null);
wrappedDictionary[keyValue] = itemValue;
}
catch (Exception ex)
{
if (IsErrorHandled(dictionary, contract, keyValue, reader as IJsonLineInfo, reader.Path, ex))
HandleError(reader, true, initialDepth);
else
throw;
}
break;
case JsonToken.Comment:
break;
case JsonToken.EndObject:
finished = true;
break;
default:
throw JsonSerializationException.Create(reader, "Unexpected token when deserializing object: " + reader.TokenType);
}
} while (!finished && reader.Read());
if (!finished)
ThrowUnexpectedEndException(reader, contract, dictionary, "Unexpected end when deserializing object.");
OnDeserialized(reader, contract, dictionary);
return dictionary;
}
private object CreateAndPopulateDictionary(JsonReader reader, JsonDictionaryContract contract, string id)
{
object dictionary;
if (contract.DefaultCreator != null &&
(!contract.DefaultCreatorNonPublic || Serializer.ConstructorHandling == ConstructorHandling.AllowNonPublicDefaultConstructor))
dictionary = contract.DefaultCreator();
else
throw CreateSerializationException(reader, "Unable to find a default constructor to use for type {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
IWrappedDictionary dictionaryWrapper = contract.CreateWrapper(dictionary);
PopulateDictionary(dictionaryWrapper, reader, contract, id);
return dictionaryWrapper.UnderlyingDictionary;
}
private void SerializeValue(JsonWriter writer, object value, JsonContract valueContract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
{
object converter;
IDictionary dictionaries;
if (value == null)
{
writer.WriteNull();
return;
}
if (member != null)
{
converter = member.Converter;
}
else
{
converter = null;
}
if (converter == null)
{
if (containerProperty != null)
{
converter = containerProperty.ItemConverter;
}
else
{
converter = null;
}
if (converter == null)
{
if (containerContract != null)
{
converter = containerContract.ItemConverter;
}
else
{
converter = null;
}
if (converter == null)
{
converter = valueContract.Converter ?? (this.Serializer.GetMatchingConverter(valueContract.UnderlyingType) ?? valueContract.InternalConverter);
}
}
}
JsonConverter jsonConverter = (JsonConverter)converter;
if (jsonConverter != null && jsonConverter.CanWrite)
{
this.SerializeConvertable(writer, jsonConverter, value, valueContract, containerContract, containerProperty);
return;
}
switch (valueContract.ContractType)
{
case JsonContractType.Object:
{
this.SerializeObject(writer, value, (JsonObjectContract)valueContract, member, containerContract, containerProperty);
return;
}
case JsonContractType.Array:
{
JsonArrayContract jsonArrayContract = (JsonArrayContract)valueContract;
if (!jsonArrayContract.IsMultidimensionalArray)
{
this.SerializeList(writer, (IEnumerable)value, jsonArrayContract, member, containerContract, containerProperty);
return;
}
this.SerializeMultidimensionalArray(writer, (Array)value, jsonArrayContract, member, containerContract, containerProperty);
return;
}
case JsonContractType.Primitive:
{
this.SerializePrimitive(writer, value, (JsonPrimitiveContract)valueContract, member, containerContract, containerProperty);
return;
}
case JsonContractType.String:
{
this.SerializeString(writer, value, (JsonStringContract)valueContract);
return;
}
case JsonContractType.Dictionary:
{
JsonDictionaryContract jsonDictionaryContract = (JsonDictionaryContract)valueContract;
JsonWriter jsonWriter = writer;
if (value is IDictionary)
{
dictionaries = (IDictionary)value;
}
else
{
dictionaries = jsonDictionaryContract.CreateWrapper(value);
}
this.SerializeDictionary(jsonWriter, dictionaries, jsonDictionaryContract, member, containerContract, containerProperty);
return;
}
case JsonContractType.Dynamic:
{
return;
}
case JsonContractType.Serializable:
{
this.SerializeISerializable(writer, (ISerializable)value, (JsonISerializableContract)valueContract, member, containerContract, containerProperty);
return;
}
case JsonContractType.Linq:
{
((JToken)value).WriteTo(writer, this.Serializer.Converters.ToArray <JsonConverter>());
return;
}
default:
{
return;
}
}
}
// Token: 0x06000C0A RID: 3082
// RVA: 0x000479FC File Offset: 0x00045BFC
private void SerializeDictionary(JsonWriter writer, IDictionary values, JsonDictionaryContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
{
IWrappedDictionary wrappedDictionary = values as IWrappedDictionary;
object obj = (wrappedDictionary != null) ? wrappedDictionary.UnderlyingDictionary : values;
this.OnSerializing(writer, contract, obj);
this._serializeStack.Add(obj);
this.WriteObjectStart(writer, obj, contract, member, collectionContract, containerProperty);
if (contract.ItemContract == null)
{
contract.ItemContract = this.Serializer._contractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object));
}
if (contract.KeyContract == null)
{
contract.KeyContract = this.Serializer._contractResolver.ResolveContract(contract.DictionaryKeyType ?? typeof(object));
}
int top = writer.Top;
foreach (DictionaryEntry dictionaryEntry in values)
{
bool escape;
string text = this.GetPropertyName(writer, dictionaryEntry.Key, contract.KeyContract, out escape);
text = ((contract.PropertyNameResolver != null) ? contract.PropertyNameResolver(text) : text);
try
{
object value = dictionaryEntry.Value;
JsonContract jsonContract = contract.FinalItemContract ?? this.GetContractSafe(value);
if (this.ShouldWriteReference(value, null, jsonContract, contract, member))
{
writer.WritePropertyName(text, escape);
this.WriteReference(writer, value);
}
else if (this.CheckForCircularReference(writer, value, null, jsonContract, contract, member))
{
writer.WritePropertyName(text, escape);
this.SerializeValue(writer, value, jsonContract, null, contract, member);
}
}
catch (Exception ex)
{
if (!base.IsErrorHandled(obj, contract, text, null, writer.ContainerPath, ex))
{
throw;
}
this.HandleError(writer, top);
}
}
writer.WriteEndObject();
this._serializeStack.RemoveAt(this._serializeStack.Count - 1);
this.OnSerialized(writer, contract, obj);
}
private void SerializeDictionary(JsonWriter writer, IWrappedDictionary values, JsonDictionaryContract contract, JsonProperty member, JsonContract collectionValueContract)
{
contract.InvokeOnSerializing(values.UnderlyingDictionary, Serializer.Context);
SerializeStack.Add(values.UnderlyingDictionary);
writer.WriteStartObject();
bool isReference = contract.IsReference ?? HasFlag(Serializer.PreserveReferencesHandling, PreserveReferencesHandling.Objects);
if (isReference)
{
writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
writer.WriteValue(Serializer.ReferenceResolver.GetReference(this, values.UnderlyingDictionary));
}
if (ShouldWriteType(TypeNameHandling.Objects, contract, member, collectionValueContract))
{
WriteTypeProperty(writer, values.UnderlyingDictionary.GetType());
}
JsonContract childValuesContract = Serializer.ContractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object));
int initialDepth = writer.Top;
// Mono Unity 3.0 fix
IDictionary d = values;
//#if !(UNITY_IPHONE || UNITY_IOS)
foreach (DictionaryEntry entry in d)
{
string propertyName = GetPropertyName(entry);
propertyName = (contract.PropertyNameResolver != null)
? contract.PropertyNameResolver(propertyName)
: propertyName;
try
{
object value = entry.Value;
JsonContract valueContract = GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract))
{
writer.WritePropertyName(propertyName);
WriteReference(writer, value);
}
else
{
if (!CheckForCircularReference(value, null, contract))
continue;
writer.WritePropertyName(propertyName);
SerializeValue(writer, value, valueContract, null, childValuesContract);
}
}
catch (Exception ex)
{
if (IsErrorHandled(values.UnderlyingDictionary, contract, propertyName, ex))
HandleError(writer, initialDepth);
else
throw;
}
}
//#else
// string propertyName;
// d.ForEach(originalEntry =>
// {
// var entry = (DictionaryEntry)originalEntry;
// propertyName = GetPropertyName(entry);
// propertyName = (contract.PropertyNameResolver != null)
// ? contract.PropertyNameResolver(propertyName)
// : propertyName;
// try
// {
// object value = entry.Value;
// JsonContract valueContract = GetContractSafe(value);
// if (ShouldWriteReference(value, null, valueContract))
// {
// writer.WritePropertyName(propertyName);
// WriteReference(writer, value);
// }
// else
// {
// if (!CheckForCircularReference(value, null, contract))
// return;
// writer.WritePropertyName(propertyName);
// SerializeValue(writer, value, valueContract, null, childValuesContract);
// }
// }
// catch (Exception ex)
// {
// if (IsErrorHandled(values.UnderlyingDictionary, contract, propertyName, ex))
// HandleError(writer, initialDepth);
// else
// throw;
// }
// });
//#endif
writer.WriteEndObject();
SerializeStack.RemoveAt(SerializeStack.Count - 1);
contract.InvokeOnSerialized(values.UnderlyingDictionary, Serializer.Context);
}
// Token: 0x06000BD1 RID: 3025
// RVA: 0x00044E70 File Offset: 0x00043070
private object PopulateDictionary(IDictionary dictionary, JsonReader reader, JsonDictionaryContract contract, JsonProperty containerProperty, string id)
{
IWrappedDictionary wrappedDictionary = dictionary as IWrappedDictionary;
object obj = (wrappedDictionary != null) ? wrappedDictionary.UnderlyingDictionary : dictionary;
if (id != null)
{
this.AddReference(reader, id, obj);
}
this.OnDeserializing(reader, contract, obj);
int depth = reader.Depth;
if (contract.KeyContract == null)
{
contract.KeyContract = this.GetContractSafe(contract.DictionaryKeyType);
}
if (contract.ItemContract == null)
{
contract.ItemContract = this.GetContractSafe(contract.DictionaryValueType);
}
JsonConverter jsonConverter = contract.ItemConverter ?? this.GetConverter(contract.ItemContract, null, contract, containerProperty);
PrimitiveTypeCode primitiveTypeCode = (contract.KeyContract is JsonPrimitiveContract) ? ((JsonPrimitiveContract)contract.KeyContract).TypeCode : PrimitiveTypeCode.Empty;
bool flag = false;
while (true)
{
JsonToken tokenType = reader.TokenType;
switch (tokenType)
{
case JsonToken.PropertyName:
{
object obj2 = reader.Value;
if (!this.CheckPropertyName(reader, obj2.ToString()))
{
try
{
try
{
DateParseHandling dateParseHandling;
switch (primitiveTypeCode)
{
case PrimitiveTypeCode.DateTime:
case PrimitiveTypeCode.DateTimeNullable:
dateParseHandling = DateParseHandling.DateTime;
break;
default:
dateParseHandling = DateParseHandling.None;
break;
}
object obj3;
if (dateParseHandling != DateParseHandling.None && DateTimeUtils.TryParseDateTime(obj2.ToString(), dateParseHandling, reader.DateTimeZoneHandling, reader.DateFormatString, reader.Culture, out obj3))
{
obj2 = obj3;
}
else
{
obj2 = this.EnsureType(reader, obj2, CultureInfo.InvariantCulture, contract.KeyContract, contract.DictionaryKeyType);
}
}
catch (Exception ex)
{
throw JsonSerializationException.Create(reader, StringUtils.FormatWith("Could not convert string '{0}' to dictionary key type '{1}'. Create a TypeConverter to convert from the string to the key type object.", CultureInfo.InvariantCulture, reader.Value, contract.DictionaryKeyType), ex);
}
if (!this.ReadForType(reader, contract.ItemContract, jsonConverter != null))
{
throw JsonSerializationException.Create(reader, "Unexpected end when deserializing object.");
}
object value;
if (jsonConverter != null && jsonConverter.CanRead)
{
value = this.DeserializeConvertable(jsonConverter, reader, contract.DictionaryValueType, null);
}
else
{
value = this.CreateValueInternal(reader, contract.DictionaryValueType, contract.ItemContract, null, contract, containerProperty, null);
}
dictionary[obj2] = value;
break;
}
catch (Exception ex2)
{
if (!base.IsErrorHandled(obj, contract, obj2, reader as IJsonLineInfo, reader.Path, ex2))
{
throw;
}
this.HandleError(reader, true, depth);
break;
}
goto IL_20B;
}
break;
}
case JsonToken.Comment:
break;
default:
goto IL_20B;
}
IL_216:
if (flag)
{
break;
}
if (!reader.Read())
{
break;
}
continue;
IL_20B:
if (tokenType != JsonToken.EndObject)
{
goto Block_10;
}
flag = true;
goto IL_216;
}
goto IL_23B;
Block_10:
throw JsonSerializationException.Create(reader, "Unexpected token when deserializing object: " + reader.TokenType);
IL_23B:
if (!flag)
{
this.ThrowUnexpectedEndException(reader, contract, obj, "Unexpected end when deserializing object.");
}
this.OnDeserialized(reader, contract, obj);
return obj;
}
protected virtual JsonDictionaryContract CreateDictionaryContract(Type objectType)
{
JsonDictionaryContract dictionaryContract = new JsonDictionaryContract(objectType);
this.InitializeContract((JsonContract) dictionaryContract);
dictionaryContract.PropertyNameResolver = new Func<string, string>(this.ResolvePropertyName);
return dictionaryContract;
}
private void SerializeDictionary(JsonWriter writer, IWrappedDictionary values, JsonDictionaryContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonContract collectionValueContract)
{
contract.InvokeOnSerializing(values.UnderlyingDictionary, Serializer.Context);
_serializeStack.Add(values.UnderlyingDictionary);
WriteObjectStart(writer, values.UnderlyingDictionary, contract, member, collectionContract, collectionValueContract);
if (contract.DictionaryValueContract == null)
{
contract.DictionaryValueContract = Serializer.ContractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object));
}
JsonContract dictionaryValueContract = (contract.DictionaryValueContract.UnderlyingType.IsSealed()) ? contract.DictionaryValueContract : null;
int initialDepth = writer.Top;
// Mono Unity 3.0 fix
IWrappedDictionary d = values;
foreach (DictionaryEntry entry in d)
{
string propertyName = GetPropertyName(entry);
propertyName = (contract.PropertyNameResolver != null)
? contract.PropertyNameResolver(propertyName)
: propertyName;
try
{
object value = entry.Value;
JsonContract valueContract = dictionaryValueContract ?? GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract, contract))
{
writer.WritePropertyName(propertyName);
WriteReference(writer, value);
}
else
{
if (!CheckForCircularReference(value, null, valueContract, contract))
{
continue;
}
writer.WritePropertyName(propertyName);
SerializeValue(writer, value, valueContract, null, contract, dictionaryValueContract);
}
}
catch (Exception ex)
{
if (IsErrorHandled(values.UnderlyingDictionary, contract, propertyName, writer.ContainerPath, ex))
{
HandleError(writer, initialDepth);
}
else
{
throw;
}
}
}
writer.WriteEndObject();
_serializeStack.RemoveAt(_serializeStack.Count - 1);
contract.InvokeOnSerialized(values.UnderlyingDictionary, Serializer.Context);
}
private void SerializeValue(JsonWriter writer, object value, JsonContract valueContract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
{
if (value == null)
{
writer.WriteNull();
return;
}
JsonConverter converter =
((member != null) ? member.Converter : null) ??
((containerProperty != null) ? containerProperty.ItemConverter : null) ??
((containerContract != null) ? containerContract.ItemConverter : null) ??
valueContract.Converter ??
Serializer.GetMatchingConverter(valueContract.UnderlyingType) ??
valueContract.InternalConverter;
if (converter != null && converter.CanWrite)
{
SerializeConvertable(writer, converter, value, valueContract, containerContract, containerProperty);
return;
}
switch (valueContract.ContractType)
{
case JsonContractType.Object:
SerializeObject(writer, value, (JsonObjectContract)valueContract, member, containerContract, containerProperty);
break;
case JsonContractType.Array:
JsonArrayContract arrayContract = (JsonArrayContract)valueContract;
if (!arrayContract.IsMultidimensionalArray)
{
SerializeList(writer, (IEnumerable)value, arrayContract, member, containerContract, containerProperty);
}
else
{
SerializeMultidimensionalArray(writer, (Array)value, arrayContract, member, containerContract, containerProperty);
}
break;
case JsonContractType.Primitive:
SerializePrimitive(writer, value, (JsonPrimitiveContract)valueContract, member, containerContract, containerProperty);
break;
case JsonContractType.String:
SerializeString(writer, value, (JsonStringContract)valueContract);
break;
case JsonContractType.Dictionary:
JsonDictionaryContract dictionaryContract = (JsonDictionaryContract)valueContract;
SerializeDictionary(writer, (value is IDictionary) ? (IDictionary)value : dictionaryContract.CreateWrapper(value), dictionaryContract, member, containerContract, containerProperty);
break;
#if !(NET35 || NET20 || PORTABLE40)
case JsonContractType.Dynamic:
SerializeDynamic(writer, (IDynamicMetaObjectProvider)value, (JsonDynamicContract)valueContract, member, containerContract, containerProperty);
break;
#endif
#if !(NETFX_CORE || PORTABLE40 || PORTABLE)
case JsonContractType.Serializable:
SerializeISerializable(writer, (ISerializable)value, (JsonISerializableContract)valueContract, member, containerContract, containerProperty);
break;
#endif
case JsonContractType.Linq:
((JToken)value).WriteTo(writer, Serializer.Converters.ToArray());
break;
}
}
private void SerializeDictionary(JsonWriter writer, IDictionary values, JsonDictionaryContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
{
object underlyingDictionary = values is IWrappedDictionary wrappedDictionary ? wrappedDictionary.UnderlyingDictionary : values;
OnSerializing(writer, contract, underlyingDictionary);
_serializeStack.Add(underlyingDictionary);
WriteObjectStart(writer, underlyingDictionary, contract, member, collectionContract, containerProperty);
if (contract.ItemContract == null)
{
contract.ItemContract = Serializer._contractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object));
}
if (contract.KeyContract == null)
{
contract.KeyContract = Serializer._contractResolver.ResolveContract(contract.DictionaryKeyType ?? typeof(object));
}
int initialDepth = writer.Top;
// Manual use of IDictionaryEnumerator instead of foreach to avoid DictionaryEntry box allocations.
IDictionaryEnumerator e = values.GetEnumerator();
try
{
while (e.MoveNext())
{
DictionaryEntry entry = e.Entry;
string propertyName = GetPropertyName(writer, entry.Key, contract.KeyContract, out bool escape);
propertyName = (contract.DictionaryKeyResolver != null)
? contract.DictionaryKeyResolver(propertyName)
: propertyName;
try
{
object value = entry.Value;
JsonContract valueContract = contract.FinalItemContract ?? GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract, contract, member))
{
writer.WritePropertyName(propertyName, escape);
WriteReference(writer, value);
}
else
{
if (!CheckForCircularReference(writer, value, null, valueContract, contract, member))
{
continue;
}
writer.WritePropertyName(propertyName, escape);
SerializeValue(writer, value, valueContract, null, contract, member);
}
}
catch (Exception ex)
{
if (IsErrorHandled(underlyingDictionary, contract, propertyName, null, writer.ContainerPath, ex))
{
HandleError(writer, initialDepth);
}
else
{
throw;
}
}
}
}
finally
{
(e as IDisposable)?.Dispose();
}
writer.WriteEndObject();
_serializeStack.RemoveAt(_serializeStack.Count - 1);
OnSerialized(writer, contract, underlyingDictionary);
}
private object PopulateDictionary(IWrappedDictionary dictionary, JsonReader reader, JsonDictionaryContract contract, string id)
{
if (id != null)
{
Serializer.ReferenceResolver.AddReference(id, dictionary.UnderlyingDictionary);
}
contract.InvokeOnDeserializing(dictionary.UnderlyingDictionary, Serializer.Context);
int initialDepth = reader.Depth;
do
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
object keyValue;
try
{
keyValue = EnsureType(reader.Value, contract.DictionaryKeyType);
}
catch (Exception ex)
{
throw new JsonSerializationException("Could not convert string '{0}' to dictionary key type '{1}'. Create a TypeConverter to convert from the string to the key type object.".FormatWith(CultureInfo.InvariantCulture, reader.Value, contract.DictionaryKeyType), ex);
}
if (!ReadForType(reader, contract.DictionaryValueType, null))
{
throw new JsonSerializationException("Unexpected end when deserializing object.");
}
try
{
dictionary[keyValue] = CreateValueNonProperty(reader, contract.DictionaryValueType, GetContractSafe(contract.DictionaryValueType));
}
catch (Exception ex)
{
if (IsErrorHandled(dictionary, contract, keyValue, ex))
{
HandleError(reader, initialDepth);
}
else
{
throw;
}
}
break;
case JsonToken.EndObject:
contract.InvokeOnDeserialized(dictionary.UnderlyingDictionary, Serializer.Context);
return(dictionary.UnderlyingDictionary);
default:
throw new JsonSerializationException("Unexpected token when deserializing object: " + reader.TokenType);
}
} while (reader.Read());
throw new JsonSerializationException("Unexpected end when deserializing object.");
}
private object CreateAndPopulateDictionary(JsonReader reader, JsonDictionaryContract contract, string id)
{
IWrappedDictionary dictionary = contract.CreateWrapper(contract.DefaultContstructor.Invoke(null));
PopulateDictionary(dictionary, reader, contract, id);
return dictionary.UnderlyingDictionary;
}
private IDictionary CreateNewDictionary(JsonReader reader, JsonDictionaryContract contract, out bool createdFromNonDefaultConstructor)
{
if (contract.IsReadOnlyOrFixedSize)
{
createdFromNonDefaultConstructor = true;
return contract.CreateTemporaryDictionary();
}
else if (contract.DefaultCreator != null && (!contract.DefaultCreatorNonPublic || Serializer._constructorHandling == ConstructorHandling.AllowNonPublicDefaultConstructor))
{
object dictionary = contract.DefaultCreator();
if (contract.ShouldCreateWrapper)
dictionary = contract.CreateWrapper(dictionary);
createdFromNonDefaultConstructor = false;
return (IDictionary) dictionary;
}
else if (contract.ParametrizedConstructor != null)
{
createdFromNonDefaultConstructor = true;
return contract.CreateTemporaryDictionary();
}
else
{
throw JsonSerializationException.Create(reader, "Unable to find a default constructor to use for type {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
}
}
private IDictionary CreateNewDictionary(JsonReader reader, JsonDictionaryContract contract, out bool createdFromNonDefaultCreator)
{
if (contract.OverrideCreator != null)
{
if (contract.HasParameterizedCreator)
{
createdFromNonDefaultCreator = true;
return contract.CreateTemporaryDictionary();
}
else
{
createdFromNonDefaultCreator = false;
return (IDictionary)contract.OverrideCreator();
}
}
else if (contract.IsReadOnlyOrFixedSize)
{
createdFromNonDefaultCreator = true;
return contract.CreateTemporaryDictionary();
}
else if (contract.DefaultCreator != null && (!contract.DefaultCreatorNonPublic || Serializer._constructorHandling == ConstructorHandling.AllowNonPublicDefaultConstructor))
{
object dictionary = contract.DefaultCreator();
if (contract.ShouldCreateWrapper)
{
dictionary = contract.CreateWrapper(dictionary);
}
createdFromNonDefaultCreator = false;
return (IDictionary)dictionary;
}
else if (contract.HasParameterizedCreatorInternal)
{
createdFromNonDefaultCreator = true;
return contract.CreateTemporaryDictionary();
}
else
{
if (!contract.IsInstantiable)
{
throw JsonSerializationException.Create(reader, "Could not create an instance of type {0}. Type is an interface or abstract class and cannot be instantiated.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
}
throw JsonSerializationException.Create(reader, "Unable to find a default constructor to use for type {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
}
}
private void SerializeDictionary(JsonWriter writer, IWrappedDictionary values, JsonDictionaryContract contract, JsonProperty member, JsonContainerContract collectionContract, JsonProperty containerProperty)
{
contract.InvokeOnSerializing(values.UnderlyingDictionary, Serializer.Context);
_serializeStack.Add(values.UnderlyingDictionary);
WriteObjectStart(writer, values.UnderlyingDictionary, contract, member, collectionContract, containerProperty);
if (contract.ItemContract == null)
contract.ItemContract = Serializer.ContractResolver.ResolveContract(contract.DictionaryValueType ?? typeof(object));
int initialDepth = writer.Top;
// Mono Unity 3.0 fix
IWrappedDictionary d = values;
foreach (DictionaryEntry entry in d)
{
string propertyName = GetPropertyName(entry);
propertyName = (contract.PropertyNameResolver != null)
? contract.PropertyNameResolver(propertyName)
: propertyName;
try
{
object value = entry.Value;
JsonContract valueContract = contract.FinalItemContract ?? GetContractSafe(value);
if (ShouldWriteReference(value, null, valueContract, contract, member))
{
writer.WritePropertyName(propertyName);
WriteReference(writer, value);
}
else
{
if (!CheckForCircularReference(writer, value, null, valueContract, contract, member))
continue;
writer.WritePropertyName(propertyName);
SerializeValue(writer, value, valueContract, null, contract, member);
}
}
catch (Exception ex)
{
if (IsErrorHandled(values.UnderlyingDictionary, contract, propertyName, writer.ContainerPath, ex))
HandleError(writer, initialDepth);
else
throw;
}
}
writer.WriteEndObject();
_serializeStack.RemoveAt(_serializeStack.Count - 1);
contract.InvokeOnSerialized(values.UnderlyingDictionary, Serializer.Context);
}
private void SerializeDictionary(JsonWriter writer, IDictionary values, JsonDictionaryContract contract)
{
contract.InvokeOnSerializing(values);
SerializeStack.Add(values);
writer.WriteStartObject();
bool isReference = contract.IsReference ?? HasFlag(_serializer.PreserveReferencesHandling, PreserveReferencesHandling.Objects);
if (isReference)
{
writer.WritePropertyName(JsonTypeReflector.IdPropertyName);
writer.WriteValue(_serializer.ReferenceResolver.GetReference(values));
}
if (HasFlag(_serializer.TypeNameHandling, TypeNameHandling.Objects))
{
WriteTypeProperty(writer, values.GetType());
}
foreach (DictionaryEntry entry in values)
{
string propertyName = entry.Key.ToString();
object value = entry.Value;
if (ShouldWriteReference(value, null))
{
writer.WritePropertyName(propertyName);
WriteReference(writer, value);
}
else
{
if (!CheckForCircularReference(value, null))
continue;
writer.WritePropertyName(propertyName);
SerializeValue(writer, value, null);
}
}
writer.WriteEndObject();
SerializeStack.RemoveAt(SerializeStack.Count - 1);
contract.InvokeOnSerialized(values);
}
private object PopulateDictionary(IWrappedDictionary dictionary, JsonReader reader, JsonDictionaryContract contract, string id)
{
if (id != null)
Serializer.ReferenceResolver.AddReference(this, id, dictionary.UnderlyingDictionary);
contract.InvokeOnDeserializing(dictionary.UnderlyingDictionary, Serializer.Context);
int initialDepth = reader.Depth;
do
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
object keyValue = reader.Value;
try
{
if (contract.DictionaryKeyContract == null)
contract.DictionaryKeyContract = GetContractSafe(contract.DictionaryKeyType);
try
{
keyValue = EnsureType(reader, keyValue, CultureInfo.InvariantCulture, contract.DictionaryKeyContract, contract.DictionaryKeyType);
}
catch (Exception ex)
{
throw CreateSerializationException(reader, "Could not convert string '{0}' to dictionary key type '{1}'. Create a TypeConverter to convert from the string to the key type object.".FormatWith(CultureInfo.InvariantCulture, reader.Value, contract.DictionaryKeyType), ex);
}
if (contract.DictionaryValueContract == null)
contract.DictionaryValueContract = GetContractSafe(contract.DictionaryValueType);
JsonConverter dictionaryValueConverter = GetConverter(contract.DictionaryValueContract, null);
if (!ReadForType(reader, contract.DictionaryValueContract, dictionaryValueConverter != null, false))
throw CreateSerializationException(reader, "Unexpected end when deserializing object.");
dictionary[keyValue] = CreateValueNonProperty(reader, contract.DictionaryValueType, contract.DictionaryValueContract, dictionaryValueConverter);
}
catch (Exception ex)
{
if (IsErrorHandled(dictionary, contract, keyValue, reader.Path, ex))
HandleError(reader, initialDepth);
else
throw;
}
break;
case JsonToken.Comment:
break;
case JsonToken.EndObject:
contract.InvokeOnDeserialized(dictionary.UnderlyingDictionary, Serializer.Context);
return dictionary.UnderlyingDictionary;
default:
throw CreateSerializationException(reader, "Unexpected token when deserializing object: " + reader.TokenType);
}
} while (reader.Read());
throw CreateSerializationException(reader, "Unexpected end when deserializing object.");
}
private void SerializeValue(JsonWriter writer, object value, JsonContract valueContract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
{
if (value == null)
{
writer.WriteNull();
return;
}
JsonConverter jsonConverter;
if (((jsonConverter = ((member != null) ? member.Converter : null)) != null || (jsonConverter = ((containerProperty != null) ? containerProperty.ItemConverter : null)) != null || (jsonConverter = ((containerContract != null) ? containerContract.ItemConverter : null)) != null || (jsonConverter = valueContract.Converter) != null || (jsonConverter = this.Serializer.GetMatchingConverter(valueContract.UnderlyingType)) != null || (jsonConverter = valueContract.InternalConverter) != null) && jsonConverter.CanWrite)
{
this.SerializeConvertable(writer, jsonConverter, value, valueContract, containerContract, containerProperty);
return;
}
switch (valueContract.ContractType)
{
case JsonContractType.Object:
this.SerializeObject(writer, value, (JsonObjectContract)valueContract, member, containerContract, containerProperty);
return;
case JsonContractType.Array:
{
JsonArrayContract jsonArrayContract = (JsonArrayContract)valueContract;
if (!jsonArrayContract.IsMultidimensionalArray)
{
this.SerializeList(writer, (IEnumerable)value, jsonArrayContract, member, containerContract, containerProperty);
return;
}
this.SerializeMultidimensionalArray(writer, (Array)value, jsonArrayContract, member, containerContract, containerProperty);
return;
}
case JsonContractType.Primitive:
this.SerializePrimitive(writer, value, (JsonPrimitiveContract)valueContract, member, containerContract, containerProperty);
return;
case JsonContractType.String:
this.SerializeString(writer, value, (JsonStringContract)valueContract);
return;
case JsonContractType.Dictionary:
{
JsonDictionaryContract jsonDictionaryContract = (JsonDictionaryContract)valueContract;
this.SerializeDictionary(writer, (value is IDictionary) ? ((IDictionary)value) : jsonDictionaryContract.CreateWrapper(value), jsonDictionaryContract, member, containerContract, containerProperty);
return;
}
case JsonContractType.Dynamic:
this.SerializeDynamic(writer, (IDynamicMetaObjectProvider)value, (JsonDynamicContract)valueContract, member, containerContract, containerProperty);
return;
case JsonContractType.Serializable:
this.SerializeISerializable(writer, (ISerializable)value, (JsonISerializableContract)valueContract, member, containerContract, containerProperty);
return;
case JsonContractType.Linq:
((JToken)value).WriteTo(writer, this.Serializer.Converters.ToArray <JsonConverter>());
return;
default:
return;
}
}