/// <summary>
/// Compares JSON properties.
/// </summary>
/// <param name="expected">Expected property./param>
/// <param name="actual">Actual property.</param>
private void CompareProperty(JsonProperty expected, JsonProperty actual)
{
assert.AreEqual(expected.Name, actual.Name, "The names of properties don't match.");
using (this.assert.WithMessage("JsonProperty {0}", expected.Name))
{
this.Compare(expected.Value, actual.Value);
}
}
internal PropertyModel(JsonProperty property, CSharpTypeResolver resolver, CSharpGeneratorSettings settings)
: base(property, new DefaultValueGenerator(resolver))
{
_property = property;
_settings = settings;
_resolver = resolver;
PropertyName = ConversionUtilities.ConvertToUpperCamelCase(GetGeneratedPropertyName(), true);
}
private bool IsEmptyCollection(JsonProperty property, object target) {
var value = property.ValueProvider.GetValue(target);
var collection = value as ICollection;
if (collection != null && collection.Count == 0)
return true;
if (typeof(IEnumerable).IsAssignableFrom(property.PropertyType)) {
var countProp = property.PropertyType.GetProperty("Count");
if (countProp == null)
return false;
var count = (int)countProp.GetValue(value, null);
return count == 0;
}
return false;
}
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 static bool ShouldSerialize(JsonProperty property)
{
return(property.DeclaringType.GetField(property.PropertyName, BindingFlags.NonPublic | BindingFlags.Public | BindingFlags.Instance | BindingFlags.GetField) != null);
}
protected override IList <JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
#if !NETFX_CORE
if (!type.IsClass || type == typeof(object) || typeof(Response).IsAssignableFrom(type) || typeof(IResponseRow).IsAssignableFrom(type))
{
return(base.CreateProperties(type, memberSerialization));
}
#else
if (type == typeof(object))
{
return(base.CreateProperties(type, memberSerialization));
}
var typeInfo = type.GetTypeInfo();
if (!typeInfo.IsClass || ResponseTypeInfo.IsAssignableFrom(typeInfo) || ResponseRowTypeInfo.IsAssignableFrom(typeInfo))
{
return(base.CreateProperties(type, memberSerialization));
}
#endif
var props = base.CreateProperties(type, memberSerialization);
if (!props.Any())
{
return(props);
}
int? idRank = null, revRank = null;
JsonProperty id = null, rev = null;
foreach (var prop in props)
{
var tmpRank = EntityReflector.IdMember.GetMemberRankingIndex(type, prop.PropertyName);
if (tmpRank != null)
{
if (idRank == null || tmpRank < idRank)
{
idRank = tmpRank;
id = prop;
}
continue;
}
tmpRank = EntityReflector.RevMember.GetMemberRankingIndex(type, prop.PropertyName);
if (tmpRank != null)
{
if (revRank == null || tmpRank < revRank)
{
revRank = tmpRank;
rev = prop;
}
}
}
if (id != null)
{
id.PropertyName = "_id";
}
if (rev != null)
{
rev.PropertyName = "_rev";
}
return(props);
}
private void SetPropertyPresence(JsonReader reader, JsonProperty property, Dictionary<JsonProperty, PropertyPresence> requiredProperties)
{
if (property != null && requiredProperties != null)
{
requiredProperties[property] = (reader.TokenType == JsonToken.Null || reader.TokenType == JsonToken.Undefined)
? PropertyPresence.Null
: PropertyPresence.Value;
}
}
protected abstract void PrepareJsonSchema(JsonProperty jsonProperty, Func <string, JsonSchema4, JsonSchema4> schemaResolver);
private object PopulateList(IList list, JsonReader reader, JsonArrayContract contract, JsonProperty containerProperty, string id)
{
IWrappedCollection wrappedCollection = list as IWrappedCollection;
object underlyingList = wrappedCollection != null ? wrappedCollection.UnderlyingCollection : list;
if (id != null)
AddReference(reader, id, underlyingList);
// can't populate an existing array
if (list.IsFixedSize)
{
reader.Skip();
return underlyingList;
}
OnDeserializing(reader, contract, underlyingList);
int initialDepth = reader.Depth;
if (contract.ItemContract == null)
contract.ItemContract = GetContractSafe(contract.CollectionItemType);
JsonConverter collectionItemConverter = GetConverter(contract.ItemContract, null, contract, containerProperty);
int? previousErrorIndex = null;
bool finished = false;
do
{
try
{
if (ReadForType(reader, contract.ItemContract, collectionItemConverter != null))
{
switch (reader.TokenType)
{
case JsonToken.EndArray:
finished = true;
break;
case JsonToken.Comment:
break;
default:
object value;
if (collectionItemConverter != null && collectionItemConverter.CanRead)
value = DeserializeConvertable(collectionItemConverter, reader, contract.CollectionItemType, null);
else
value = CreateValueInternal(reader, contract.CollectionItemType, contract.ItemContract, null, contract, containerProperty, null);
list.Add(value);
break;
}
}
else
{
break;
}
}
catch (Exception ex)
{
JsonPosition errorPosition = reader.GetPosition(initialDepth);
if (IsErrorHandled(underlyingList, contract, errorPosition.Position, reader as IJsonLineInfo, reader.Path, ex))
{
HandleError(reader, true, initialDepth);
if (previousErrorIndex != null && previousErrorIndex == errorPosition.Position)
{
// reader index has not moved since previous error handling
// break out of reading array to prevent infinite loop
throw JsonSerializationException.Create(reader, "Infinite loop detected from error handling.", ex);
}
else
{
previousErrorIndex = errorPosition.Position;
}
}
else
{
throw;
}
}
} while (!finished);
if (!finished)
ThrowUnexpectedEndException(reader, contract, underlyingList, "Unexpected end when deserializing array.");
OnDeserialized(reader, contract, underlyingList);
return underlyingList;
}
private IDictionary<JsonProperty, object> ResolvePropertyAndCreatorValues(JsonObjectContract contract, JsonProperty containerProperty, JsonReader reader, Type objectType, out IDictionary<string, object> extensionData)
{
extensionData = (contract.ExtensionDataSetter != null) ? new Dictionary<string, object>() : null;
IDictionary<JsonProperty, object> propertyValues = new Dictionary<JsonProperty, object>();
bool exit = false;
do
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
string memberName = reader.Value.ToString();
// attempt exact case match first
// then try match ignoring case
JsonProperty property = contract.CreatorParameters.GetClosestMatchProperty(memberName) ??
contract.Properties.GetClosestMatchProperty(memberName);
if (property != null)
{
if (property.PropertyContract == null)
property.PropertyContract = GetContractSafe(property.PropertyType);
JsonConverter propertyConverter = GetConverter(property.PropertyContract, property.MemberConverter, contract, containerProperty);
if (!ReadForType(reader, property.PropertyContract, propertyConverter != null))
throw JsonSerializationException.Create(reader, "Unexpected end when setting {0}'s value.".FormatWith(CultureInfo.InvariantCulture, memberName));
if (!property.Ignored)
{
if (property.PropertyContract == null)
property.PropertyContract = GetContractSafe(property.PropertyType);
object propertyValue;
if (propertyConverter != null && propertyConverter.CanRead)
propertyValue = DeserializeConvertable(propertyConverter, reader, property.PropertyType, null);
else
propertyValue = CreateValueInternal(reader, property.PropertyType, property.PropertyContract, property, contract, containerProperty, null);
propertyValues[property] = propertyValue;
continue;
}
}
else
{
if (!reader.Read())
throw JsonSerializationException.Create(reader, "Unexpected end when setting {0}'s value.".FormatWith(CultureInfo.InvariantCulture, memberName));
if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
TraceWriter.Trace(TraceLevel.Verbose, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "Could not find member '{0}' on {1}.".FormatWith(CultureInfo.InvariantCulture, memberName, contract.UnderlyingType)), null);
if (Serializer._missingMemberHandling == MissingMemberHandling.Error)
throw JsonSerializationException.Create(reader, "Could not find member '{0}' on object of type '{1}'".FormatWith(CultureInfo.InvariantCulture, memberName, objectType.Name));
}
if (extensionData != null)
{
object value = CreateValueInternal(reader, null, null, null, contract, containerProperty, null);
extensionData[memberName] = value;
}
else
{
reader.Skip();
}
break;
case JsonToken.Comment:
break;
case JsonToken.EndObject:
exit = true;
break;
default:
throw JsonSerializationException.Create(reader, "Unexpected token when deserializing object: " + reader.TokenType);
}
} while (!exit && reader.Read());
return propertyValues;
}
protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization memberSerialization)
{
JsonProperty property = base.CreateProperty(member, memberSerialization);
var pi = member as PropertyInfo;
//if (pi != null && pi.PropertyType == typeof(CmSeperator))
//{
// property.Ignored = true;
//}
property.ShouldSerialize = instance =>
{
if (property.PropertyName == "CompositionAliases")
{
return(false);
}
if (property.PropertyName == "ContentSet")
{
return(false);
}
if (property.PropertyName == "PropertyTypes")
{
return(false);
}
if (property.PropertyName == "Properties")
{
return(false);
}
if (property.PropertyName == "Parent")
{
return(false);
}
if (property.PropertyName == "Children")
{
return(false);
}
if (property.PropertyName == "DocumentTypeId")
{
return(false);
}
if (property.PropertyName == "WriterName")
{
return(false);
}
if (property.PropertyName == "CreatorName")
{
return(false);
}
if (property.PropertyName == "WriterId")
{
return(false);
}
if (property.PropertyName == "CreatorId")
{
return(false);
}
if (property.PropertyName == "CreateDate")
{
return(false);
}
if (property.PropertyName == "UpdateDate")
{
return(false);
}
if (property.PropertyName == "Version")
{
return(false);
}
if (property.PropertyName == "SortOrder")
{
return(false);
}
if (property.PropertyName == "TemplateId")
{
return(false);
}
if (property.PropertyName == "IsDraft")
{
return(false);
}
if (property.PropertyName == "ItemType")
{
return(false);
}
if (property.PropertyName == "ContentType")
{
return(false);
}
if (property.PropertyName == "ContentSet")
{
return(false);
}
if (property.PropertyName == "Path")
{
return(false); //override path with patharray to make it an array
}
if (property.PropertyName == "SeoMetaDescription")
{
return(false);
}
if (property.PropertyName == "Seodashboard")
{
return(false);
}
if (property.PropertyName == "Preview")
{
return(false);
}
if (property.PropertyName == "SeoTitle")
{
return(false);
}
//ADD CUSTOM OVERRRIDES AFTER THIS IN THE ABOVE FORMAT
property.PropertyName = StringUtils.ToCamelCase(property.PropertyName);
return(true);
};
return(property);
}
private static object GenerateJsonObjectFromJsonSchema4(JsonProperty value, bool UseXMlNames)
{
object output = "";
switch (value.Type)
{
case JsonObjectType.Object:
Dictionary <string, object> JsonBody = new Dictionary <string, object>();
foreach (KeyValuePair <string, JsonProperty> jkp in value.ActualProperties)
{
string key = jkp.Key;
if (UseXMlNames && jkp.Value.Xml != null)
{
key = jkp.Value.Xml.Name;
}
JsonBody.Add(key, JsonConvert.SerializeObject(GenerateJsonObjectFromJsonSchema4(jkp.Value, UseXMlNames)));
}
output = JsonBody;
break;
case JsonObjectType.Array:
JObject jb = new JObject();
foreach (var item in value.Item.ActualProperties)
{
string key = item.Key;
if (UseXMlNames && item.Value.Xml != null)
{
key = item.Value.Xml.Name;
}
jb.Add(key, JsonConvert.SerializeObject(GenerateJsonObjectFromJsonSchema4(item.Value, UseXMlNames)));
}
if (value.Item.HasReference)
{
foreach (var item in value.Item.Reference.ActualProperties)
{
if (item.Value.Equals(value))
{
jb.Add(item.Key, "");
}
else
{
string key = item.Key;
if (key.ToUpper() == "orderTerm".ToUpper())
{
}
if (UseXMlNames && item.Value.Xml != null)
{
key = item.Value.Xml.Name;
}
jb.Add(key, JsonConvert.SerializeObject(GenerateJsonObjectFromJsonSchema4(item.Value, UseXMlNames)));
}
}
}
JArray ja = new JArray();
ja.Add(jb);
output = ja;
if (UseXMlNames)
{
Dictionary <string, object> jsb = new Dictionary <string, object>();
jsb.Add(value.Xml.Name, ja);
output = jsb;
}
break;
case JsonObjectType.String:
output = new JValue("sample");
break;
case JsonObjectType.Number:
output = new JValue(1);
break;
case JsonObjectType.Integer:
output = new JValue(1);
break;
case JsonObjectType.Boolean:
output = new JValue(false);
break;
case JsonObjectType.Null:
output = JValue.CreateNull();
break;
default:
output = new JValue("");;
break;
}
return(output);
}
public void Verify()
{
Assert.Equal((short)1, MyInt16);
Assert.Equal((int)2, MyInt32);
Assert.Equal((long)3, MyInt64);
Assert.Equal((ushort)4, MyUInt16);
Assert.Equal((uint)5, MyUInt32);
Assert.Equal((ulong)6, MyUInt64);
Assert.Equal((byte)7, MyByte);
Assert.Equal((sbyte)8, MySByte);
Assert.Equal('a', MyChar);
Assert.Equal("Hello", MyString);
Assert.Equal(3.3m, MyDecimal);
Assert.Equal(false, MyBooleanFalse);
Assert.Equal(true, MyBooleanTrue);
Assert.Equal(1.1f, MySingle);
Assert.Equal(2.2d, MyDouble);
Assert.Equal(new DateTime(2019, 1, 30, 12, 1, 2, DateTimeKind.Utc), MyDateTime);
Assert.Equal(new DateTimeOffset(2019, 1, 30, 12, 1, 2, new TimeSpan(1, 0, 0)), MyDateTimeOffset);
Assert.Equal(SampleEnum.Two, MyEnum);
Assert.Equal((short)1, MyInt16Array[0]);
Assert.Equal((int)2, MyInt32Array[0]);
Assert.Equal((long)3, MyInt64Array[0]);
Assert.Equal((ushort)4, MyUInt16Array[0]);
Assert.Equal((uint)5, MyUInt32Array[0]);
Assert.Equal((ulong)6, MyUInt64Array[0]);
Assert.Equal((byte)7, MyByteArray[0]);
Assert.Equal((sbyte)8, MySByteArray[0]);
Assert.Equal('a', MyCharArray[0]);
Assert.Equal("Hello", MyStringArray[0]);
Assert.Equal(3.3m, MyDecimalArray[0]);
Assert.Equal(false, MyBooleanFalseArray[0]);
Assert.Equal(true, MyBooleanTrueArray[0]);
Assert.Equal(1.1f, MySingleArray[0]);
Assert.Equal(2.2d, MyDoubleArray[0]);
Assert.Equal(new DateTime(2019, 1, 30, 12, 1, 2, DateTimeKind.Utc), MyDateTimeArray[0]);
Assert.Equal(new DateTimeOffset(2019, 1, 30, 12, 1, 2, new TimeSpan(1, 0, 0)), MyDateTimeOffsetArray[0]);
Assert.Equal(SampleEnum.Two, MyEnumArray[0]);
Assert.Equal(10, MyInt16TwoDimensionArray[0][0]);
Assert.Equal(11, MyInt16TwoDimensionArray[0][1]);
Assert.Equal(20, MyInt16TwoDimensionArray[1][0]);
Assert.Equal(21, MyInt16TwoDimensionArray[1][1]);
Assert.Equal(10, MyInt16TwoDimensionList[0][0]);
Assert.Equal(11, MyInt16TwoDimensionList[0][1]);
Assert.Equal(20, MyInt16TwoDimensionList[1][0]);
Assert.Equal(21, MyInt16TwoDimensionList[1][1]);
Assert.Equal(11, MyInt16ThreeDimensionArray[0][0][0]);
Assert.Equal(12, MyInt16ThreeDimensionArray[0][0][1]);
Assert.Equal(13, MyInt16ThreeDimensionArray[0][1][0]);
Assert.Equal(14, MyInt16ThreeDimensionArray[0][1][1]);
Assert.Equal(21, MyInt16ThreeDimensionArray[1][0][0]);
Assert.Equal(22, MyInt16ThreeDimensionArray[1][0][1]);
Assert.Equal(23, MyInt16ThreeDimensionArray[1][1][0]);
Assert.Equal(24, MyInt16ThreeDimensionArray[1][1][1]);
Assert.Equal(11, MyInt16ThreeDimensionList[0][0][0]);
Assert.Equal(12, MyInt16ThreeDimensionList[0][0][1]);
Assert.Equal(13, MyInt16ThreeDimensionList[0][1][0]);
Assert.Equal(14, MyInt16ThreeDimensionList[0][1][1]);
Assert.Equal(21, MyInt16ThreeDimensionList[1][0][0]);
Assert.Equal(22, MyInt16ThreeDimensionList[1][0][1]);
Assert.Equal(23, MyInt16ThreeDimensionList[1][1][0]);
Assert.Equal(24, MyInt16ThreeDimensionList[1][1][1]);
Assert.Equal("Hello", MyStringList[0]);
IEnumerator enumerator = MyStringIEnumerable.GetEnumerator();
enumerator.MoveNext();
{
// Verifying after deserialization.
if (enumerator.Current is JsonElement currentJsonElement)
{
Assert.Equal("Hello", currentJsonElement.GetString());
}
// Verifying test data.
else
{
Assert.Equal("Hello", enumerator.Current);
}
}
{
// Verifying after deserialization.
if (MyStringIList[0] is JsonElement currentJsonElement)
{
Assert.Equal("Hello", currentJsonElement.GetString());
}
// Verifying test data.
else
{
Assert.Equal("Hello", enumerator.Current);
}
}
enumerator = MyStringICollection.GetEnumerator();
enumerator.MoveNext();
{
// Verifying after deserialization.
if (enumerator.Current is JsonElement currentJsonElement)
{
Assert.Equal("Hello", currentJsonElement.GetString());
}
// Verifying test data.
else
{
Assert.Equal("Hello", enumerator.Current);
}
}
Assert.Equal("Hello", MyStringIEnumerableT.First());
Assert.Equal("Hello", MyStringIListT[0]);
Assert.Equal("Hello", MyStringICollectionT.First());
Assert.Equal("Hello", MyStringIReadOnlyCollectionT.First());
Assert.Equal("Hello", MyStringIReadOnlyListT[0]);
Assert.Equal("Hello", MyStringISetT.First());
enumerator = MyStringToStringIDict.GetEnumerator();
enumerator.MoveNext();
{
// Verifying after deserialization.
if (enumerator.Current is JsonElement currentJsonElement)
{
IEnumerator jsonEnumerator = currentJsonElement.EnumerateObject();
jsonEnumerator.MoveNext();
JsonProperty property = (JsonProperty)jsonEnumerator.Current;
Assert.Equal("key", property.Name);
Assert.Equal("value", property.Value.GetString());
}
// Verifying test data.
else
{
DictionaryEntry entry = (DictionaryEntry)enumerator.Current;
Assert.Equal("key", entry.Key);
if (entry.Value is JsonElement element)
{
Assert.Equal("value", element.GetString());
}
else
{
Assert.Equal("value", entry.Value);
}
}
}
Assert.Equal("value", MyStringToStringGenericDict["key"]);
Assert.Equal("value", MyStringToStringGenericIDict["key"]);
Assert.Equal("value", MyStringToStringGenericIReadOnlyDict["key"]);
Assert.Equal("value", MyStringToStringImmutableDict["key"]);
Assert.Equal("value", MyStringToStringIImmutableDict["key"]);
Assert.Equal("value", MyStringToStringImmutableSortedDict["key"]);
//Assert.Equal("myKey", MyStringToStringKeyValuePair.Key);
//Assert.Equal("myValue", MyStringToStringKeyValuePair.Value);
Assert.Equal(2, MyStringStackT.Count);
Assert.True(MyStringStackT.Contains("Hello"));
Assert.True(MyStringStackT.Contains("World"));
string[] expectedQueue = { "Hello", "World" };
int i = 0;
foreach (string item in MyStringQueueT)
{
Assert.Equal(expectedQueue[i], item);
i++;
}
Assert.Equal("Hello", MyStringHashSetT.First());
Assert.Equal("Hello", MyStringLinkedListT.First());
Assert.Equal("Hello", MyStringSortedSetT.First());
Assert.Equal("Hello", MyStringIImmutableListT[0]);
Assert.Equal("Hello", MyStringIImmutableStackT.First());
Assert.Equal("Hello", MyStringIImmutableQueueT.First());
Assert.Equal("Hello", MyStringIImmutableSetT.First());
Assert.Equal("Hello", MyStringImmutableHashSetT.First());
Assert.Equal("Hello", MyStringImmutableListT[0]);
Assert.Equal("Hello", MyStringImmutableStackT.First());
Assert.Equal("Hello", MyStringImmutablQueueT.First());
Assert.Equal("Hello", MyStringImmutableSortedSetT.First());
Assert.Null(MyListOfNullString[0]);
}
protected virtual void ModifyProperty(MemberInfo member, JsonProperty property)
{
// custom rule for modify property
}
public static P WalkProperties <P, T>(JsonProperty jp, T originParent) where P : IProperty, new() where T : IJsonOperation, new()
{
var key = jp.Name.Trim();
var instance = new P()
{
Name = key, OverrideProperty = originParent.OverrideProperty
};
var jElement = jp.Value;
instance.RawValueText = jElement.GetRawText();
if (!string.IsNullOrEmpty(instance.RawValueText))
{
instance.ValueText = Regex.Replace(instance.RawValueText, "\x22", string.Empty);
}
switch (jElement.ValueKind)
{
case JsonValueKind.Null:
case JsonValueKind.String:
// Is this a datetime?
if (!string.IsNullOrEmpty(instance.ValueText))
{
if (char.IsDigit(instance.ValueText[0]))
{
instance.IsDateTime = DateTimeOffset.TryParse(instance.ValueText, out DateTimeOffset date);
if (instance.IsDateTime)
{
instance.Date = date;
}
}
if (!instance.IsDateTime && instance.ValueText.Length > 50)
{
instance.IsLargeString = true;
}
}
instance.JsonType = JsonPropType.StrType;
instance.Size = jElement.GetRawText().Length;
break;
case JsonValueKind.Number:
instance.JsonType = JsonPropType.NumberType;
break;
case JsonValueKind.True:
case JsonValueKind.False:
instance.JsonType = JsonPropType.BoolType;
break;
//case JsonValueKind.Null:
// base.Header = $"{key} : null";
// break;
case JsonValueKind.Array:
case JsonValueKind.Object:
// Check to see if it is groundhog day and and a duplicate was found.
if (!originParent.SubClasses.Any(cl =>
cl.Name.Equals(key, StringComparison.InvariantCultureIgnoreCase)))
{
// Set a property to a user type
instance.JsonType = JsonPropType.UserType;
// Generate a sub object UserType which is named as the key
var sub = new T()
{
Name = key, IsSubClass = true
};
// Add it to the origin parent
originParent.SubClasses.Add(sub);
// Recurse back into processing
WalkStructure <T, P>(jElement, sub, originParent);
}
break;
}
return(instance);
}
private JsonProperty CreatePropertyFromConstructorParameterWithConstructorInfo(JsonProperty matchingMemberProperty, ParameterInfo parameterInfo, ConstructorInfo constructor = null)
{
if (matchingMemberProperty == null)
{
var constructorMessage = constructor == null
? string.Empty
: constructor.DeclaringType.FullName;
var parameterMessage = parameterInfo == null
? "all parameters"
: string.Format(CultureInfo.InvariantCulture, "parameter '{0}'", parameterInfo.Name);
string message = string.Format(
CultureInfo.InvariantCulture,
"Constructor for '{0}' requires {1}; but it was not found in the json",
constructorMessage,
parameterMessage);
throw new JsonSerializationException(message);
}
var property = base.CreatePropertyFromConstructorParameter(matchingMemberProperty, parameterInfo);
if (property != null)
{
var required = matchingMemberProperty.Required;
if (required == Required.Default)
{
if (matchingMemberProperty.PropertyType != null &&
matchingMemberProperty.PropertyType.IsValueType &&
Nullable.GetUnderlyingType(matchingMemberProperty.PropertyType) == null)
{
required = Required.Always;
}
else
{
// this does NOT mean that the parameter is not required
// the property must be defined in JSON, but can be null
required = Required.AllowNull;
}
property.Required = matchingMemberProperty.Required = required;
}
}
return(property);
}
/// <inheritdoc />
protected override JsonProperty CreatePropertyFromConstructorParameter(JsonProperty matchingMemberProperty, ParameterInfo parameterInfo)
{
return(this.CreatePropertyFromConstructorParameterWithConstructorInfo(matchingMemberProperty, parameterInfo));
}
/// <summary>
/// Visits a json property.
/// </summary>
/// <param name="jsonProperty">The json property being visited.</param>
public void Visit(JsonProperty jsonProperty)
{
ExceptionUtilities.CheckArgumentNotNull(jsonProperty, "jsonProperty");
this.writer.WriteName(jsonProperty.Name);
jsonProperty.Value.Accept(this);
}
protected abstract void PopulateShouldSerializeMethod(JsonProperty property, PropertyInfo propertyInfo);
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;
if (CheckPropertyName(reader, keyValue.ToString()))
continue;
try
{
try
{
DateParseHandling dateParseHandling;
switch (keyTypeCode)
{
case PrimitiveTypeCode.DateTime:
case PrimitiveTypeCode.DateTimeNullable:
dateParseHandling = DateParseHandling.DateTime;
break;
#if !NET20
case PrimitiveTypeCode.DateTimeOffset:
case PrimitiveTypeCode.DateTimeOffsetNullable:
dateParseHandling = DateParseHandling.DateTimeOffset;
break;
#endif
default:
dateParseHandling = DateParseHandling.None;
break;
}
// this is for correctly reading ISO and MS formatted dictionary keys
object dt;
if (dateParseHandling != DateParseHandling.None && DateTimeUtils.TryParseDateTime(keyValue.ToString(), dateParseHandling, reader.DateTimeZoneHandling, reader.DateFormatString, reader.Culture, out dt))
keyValue = dt;
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;
}
public static JsonDynamicObject Parse(ReadOnlySpan <byte> utf8, int expectedNumberOfProperties = -1)
{
Stack <JsonDynamicObject> stack = new Stack <JsonDynamicObject>();
if (expectedNumberOfProperties == -1)
{
expectedNumberOfProperties = utf8.Length >> 3;
}
var properties = new Dictionary <JsonProperty, JsonValue>(expectedNumberOfProperties);
stack.Push(new JsonDynamicObject(properties));
var reader = new Utf8JsonReader(utf8);
while (reader.Read())
{
switch (reader.TokenType)
{
case JsonTokenType.PropertyName:
var name = new Utf8String(reader.Value);
reader.Read(); // Move to the value token
var type = reader.TokenType;
var current = stack.Peek();
var property = new JsonProperty(current, name);
switch (type)
{
case JsonTokenType.String:
current._properties[property] = new JsonValue(new Utf8String(reader.Value));
break;
case JsonTokenType.StartObject: // TODO: could this be lazy? Could this reuse the root JsonObject (which would store non-allocating JsonDom)?
var newObj = new JsonDynamicObject(properties);
current._properties[property] = new JsonValue(newObj);
stack.Push(newObj);
break;
case JsonTokenType.True:
current._properties[property] = new JsonValue(type);
break;
case JsonTokenType.False:
current._properties[property] = new JsonValue(type);
break;
case JsonTokenType.Null:
current._properties[property] = new JsonValue(type);
break;
case JsonTokenType.Number:
current._properties[property] = new JsonValue(new Utf8String(reader.Value), type);
break;
case JsonTokenType.StartArray:
throw new NotImplementedException("array support not implemented yet.");
default:
throw new NotSupportedException();
}
break;
case JsonTokenType.StartObject:
break;
case JsonTokenType.EndObject:
if (stack.Count != 1)
{
stack.Pop();
}
break;
case JsonTokenType.StartArray:
throw new NotImplementedException("array support not implemented yet.");
case JsonTokenType.EndArray:
case JsonTokenType.String:
case JsonTokenType.True:
case JsonTokenType.False:
case JsonTokenType.Null:
case JsonTokenType.Number:
break;
default:
throw new NotSupportedException();
}
}
return(stack.Peek());
}
private object CreateDynamic(JsonReader reader, JsonDynamicContract contract, JsonProperty member, string id)
{
IDynamicMetaObjectProvider newObject;
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));
if (contract.DefaultCreator != null &&
(!contract.DefaultCreatorNonPublic || Serializer._constructorHandling == ConstructorHandling.AllowNonPublicDefaultConstructor))
newObject = (IDynamicMetaObjectProvider)contract.DefaultCreator();
else
throw JsonSerializationException.Create(reader, "Unable to find a default constructor to use for type {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
if (id != null)
AddReference(reader, id, newObject);
OnDeserializing(reader, contract, newObject);
int initialDepth = reader.Depth;
bool finished = false;
do
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
string memberName = reader.Value.ToString();
try
{
if (!reader.Read())
throw JsonSerializationException.Create(reader, "Unexpected end when setting {0}'s value.".FormatWith(CultureInfo.InvariantCulture, memberName));
// first attempt to find a settable property, otherwise fall back to a dynamic set without type
JsonProperty property = contract.Properties.GetClosestMatchProperty(memberName);
if (property != null && property.Writable && !property.Ignored)
{
if (property.PropertyContract == null)
property.PropertyContract = GetContractSafe(property.PropertyType);
JsonConverter propertyConverter = GetConverter(property.PropertyContract, property.MemberConverter, null, null);
if (!SetPropertyValue(property, propertyConverter, null, member, reader, newObject))
reader.Skip();
}
else
{
Type t = (JsonReader.IsPrimitiveToken(reader.TokenType)) ? reader.ValueType : typeof(IDynamicMetaObjectProvider);
JsonContract dynamicMemberContract = GetContractSafe(t);
JsonConverter dynamicMemberConverter = GetConverter(dynamicMemberContract, null, null, member);
object value;
if (dynamicMemberConverter != null && dynamicMemberConverter.CanRead)
value = DeserializeConvertable(dynamicMemberConverter, reader, t, null);
else
value = CreateValueInternal(reader, t, dynamicMemberContract, null, null, member, null);
contract.TrySetMember(newObject, memberName, value);
}
}
catch (Exception ex)
{
if (IsErrorHandled(newObject, contract, memberName, reader as IJsonLineInfo, reader.Path, ex))
HandleError(reader, true, initialDepth);
else
throw;
}
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, newObject, "Unexpected end when deserializing object.");
OnDeserialized(reader, contract, newObject);
return newObject;
}
internal static object HandleValue(JToken value, JsonSerializer serializer, CancellationToken CancellationToken, JsonProperty jsonProperty = null, string TypeDiscriminator = "speckle_type")
{
if (CancellationToken.IsCancellationRequested)
{
return(null); // Check for cancellation
}
if (value is JValue)
{
if (jsonProperty != null)
{
return(value.ToObject(jsonProperty.PropertyType));
}
else
{
return(((JValue)value).Value);
}
}
// Lists
if (value is JArray)
{
if (CancellationToken.IsCancellationRequested)
{
return(null); // Check for cancellation
}
if (jsonProperty != null && jsonProperty.PropertyType.GetConstructor(Type.EmptyTypes) != null)
{
var arr = Activator.CreateInstance(jsonProperty.PropertyType);
var addMethod = arr.GetType().GetMethod("Add");
var hasGenericType = jsonProperty.PropertyType.GenericTypeArguments.Count() != 0;
foreach (var val in ((JArray)value))
{
if (CancellationToken.IsCancellationRequested)
{
return(null); // Check for cancellation
}
if (val == null)
{
continue;
}
var item = HandleValue(val, serializer, CancellationToken);
if (item is DataChunk chunk)
{
foreach (var dataItem in chunk.data)
{
if (hasGenericType && !jsonProperty.PropertyType.GenericTypeArguments[0].IsInterface)
{
if (jsonProperty.PropertyType.GenericTypeArguments[0].IsAssignableFrom(dataItem.GetType()))
{
addMethod.Invoke(arr, new object[] { dataItem });
}
else
{
addMethod.Invoke(arr, new object[] { Convert.ChangeType(dataItem, jsonProperty.PropertyType.GenericTypeArguments[0]) });
}
}
else
{
addMethod.Invoke(arr, new object[] { dataItem });
}
}
}
else if (hasGenericType && !jsonProperty.PropertyType.GenericTypeArguments[0].IsInterface)
{
if (jsonProperty.PropertyType.GenericTypeArguments[0].IsAssignableFrom(item.GetType()))
{
addMethod.Invoke(arr, new object[] { item });
}
else
{
addMethod.Invoke(arr, new object[] { Convert.ChangeType(item, jsonProperty.PropertyType.GenericTypeArguments[0]) });
}
}
else
{
addMethod.Invoke(arr, new object[] { item });
}
}
return(arr);
}
else if (jsonProperty != null)
{
if (CancellationToken.IsCancellationRequested)
{
return(null); // Check for cancellation
}
var arr = Activator.CreateInstance(typeof(List <>).MakeGenericType(jsonProperty.PropertyType.GetElementType()));
foreach (var val in ((JArray)value))
{
if (CancellationToken.IsCancellationRequested)
{
return(null); // Check for cancellation
}
if (val == null)
{
continue;
}
var item = HandleValue(val, serializer, CancellationToken);
if (item is DataChunk chunk)
{
foreach (var dataItem in chunk.data)
{
if (!jsonProperty.PropertyType.GetElementType().IsInterface)
{
((IList)arr).Add(Convert.ChangeType(dataItem, jsonProperty.PropertyType.GetElementType()));
}
else
{
((IList)arr).Add(dataItem);
}
}
}
else
{
if (!jsonProperty.PropertyType.GetElementType().IsInterface)
{
((IList)arr).Add(Convert.ChangeType(item, jsonProperty.PropertyType.GetElementType()));
}
else
{
((IList)arr).Add(item);
}
}
}
var actualArr = Array.CreateInstance(jsonProperty.PropertyType.GetElementType(), ((IList)arr).Count);
((IList)arr).CopyTo(actualArr, 0);
return(actualArr);
}
else
{
if (CancellationToken.IsCancellationRequested)
{
return(null); // Check for cancellation
}
var arr = new List <object>();
foreach (var val in ((JArray)value))
{
if (CancellationToken.IsCancellationRequested)
{
return(null); // Check for cancellation
}
if (val == null)
{
continue;
}
var item = HandleValue(val, serializer, CancellationToken);
if (item is DataChunk chunk)
{
arr.AddRange(chunk.data);
}
else
{
arr.Add(item);
}
}
return(arr);
}
}
if (CancellationToken.IsCancellationRequested)
{
return(null); // Check for cancellation
}
if (value is JObject)
{
if (((JObject)value).Property(TypeDiscriminator) != null)
{
return(value.ToObject <Base>(serializer));
}
var dict = jsonProperty != null?Activator.CreateInstance(jsonProperty.PropertyType) : new Dictionary <string, object>();
foreach (var prop in ((JObject)value))
{
if (CancellationToken.IsCancellationRequested)
{
return(null); // Check for cancellation
}
object key = prop.Key;
if (jsonProperty != null)
{
key = Convert.ChangeType(prop.Key, jsonProperty.PropertyType.GetGenericArguments()[0]);
}
((IDictionary)dict)[key] = HandleValue(prop.Value, serializer, CancellationToken);
}
return(dict);
}
return(null);
}
private object PopulateObject(object newObject, JsonReader reader, JsonObjectContract contract, JsonProperty member, string id)
{
OnDeserializing(reader, contract, newObject);
// only need to keep a track of properies presence if they are required or a value should be defaulted if missing
Dictionary<JsonProperty, PropertyPresence> propertiesPresence = (contract.HasRequiredOrDefaultValueProperties || HasFlag(Serializer._defaultValueHandling, DefaultValueHandling.Populate))
? contract.Properties.ToDictionary(m => m, m => PropertyPresence.None)
: null;
if (id != null)
AddReference(reader, id, newObject);
int initialDepth = reader.Depth;
bool finished = false;
do
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
{
string memberName = reader.Value.ToString();
if (CheckPropertyName(reader, memberName))
continue;
try
{
// attempt exact case match first
// then try match ignoring case
JsonProperty property = contract.Properties.GetClosestMatchProperty(memberName);
if (property == null)
{
if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
TraceWriter.Trace(TraceLevel.Verbose, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "Could not find member '{0}' on {1}".FormatWith(CultureInfo.InvariantCulture, memberName, contract.UnderlyingType)), null);
if (Serializer._missingMemberHandling == MissingMemberHandling.Error)
throw JsonSerializationException.Create(reader, "Could not find member '{0}' on object of type '{1}'".FormatWith(CultureInfo.InvariantCulture, memberName, contract.UnderlyingType.Name));
if (!reader.Read())
break;
SetExtensionData(contract, member, reader, memberName, newObject);
continue;
}
if (property.PropertyContract == null)
property.PropertyContract = GetContractSafe(property.PropertyType);
JsonConverter propertyConverter = GetConverter(property.PropertyContract, property.MemberConverter, contract, member);
if (!ReadForType(reader, property.PropertyContract, propertyConverter != null))
throw JsonSerializationException.Create(reader, "Unexpected end when setting {0}'s value.".FormatWith(CultureInfo.InvariantCulture, memberName));
SetPropertyPresence(reader, property, propertiesPresence);
// set extension data if property is ignored or readonly
if (!SetPropertyValue(property, propertyConverter, contract, member, reader, newObject))
SetExtensionData(contract, member, reader, memberName, newObject);
}
catch (Exception ex)
{
if (IsErrorHandled(newObject, contract, memberName, reader as IJsonLineInfo, reader.Path, ex))
HandleError(reader, true, initialDepth);
else
throw;
}
break;
}
case JsonToken.EndObject:
finished = true;
break;
case JsonToken.Comment:
// ignore
break;
default:
throw JsonSerializationException.Create(reader, "Unexpected token when deserializing object: " + reader.TokenType);
}
} while (!finished && reader.Read());
if (!finished)
ThrowUnexpectedEndException(reader, contract, newObject, "Unexpected end when deserializing object.");
EndObject(newObject, reader, contract, initialDepth, propertiesPresence);
OnDeserialized(reader, contract, newObject);
return newObject;
}
private void LoadProperty(PropertyInfo property, JsonSchema4 parentSchema, JsonSchema4 rootSchema, ISchemaDefinitionAppender schemaDefinitionAppender, ISchemaResolver schemaResolver)
{
var propertyType = property.PropertyType;
var propertyTypeDescription = JsonObjectTypeDescription.FromType(propertyType, property.GetCustomAttributes(), Settings.DefaultEnumHandling);
var attributes = property.GetCustomAttributes().ToArray();
if (attributes.All(a => !(a is JsonIgnoreAttribute)))
{
if (propertyType.Name == "Nullable`1")
{
propertyType = propertyType.GenericTypeArguments[0];
}
JsonProperty jsonProperty;
if (!propertyTypeDescription.IsDictionary && (propertyTypeDescription.Type.HasFlag(JsonObjectType.Object) || propertyTypeDescription.IsEnum))
{
var jsonPropertySchema = Generate <JsonSchema4>(propertyType, rootSchema, property.GetCustomAttributes(), schemaDefinitionAppender, schemaResolver);
if (jsonPropertySchema.ActualSchema.IsAnyType)
{
jsonProperty = JsonProperty.FromJsonSchema(string.Empty, jsonPropertySchema.ActualSchema);
}
else
{
jsonProperty = new JsonProperty();
jsonProperty.SchemaReference = jsonPropertySchema.ActualSchema;
// schema is automatically added to Definitions if it is missing in JsonPathUtilities.GetJsonPath()
}
}
else
{
jsonProperty = Generate <JsonProperty>(propertyType, rootSchema, property.GetCustomAttributes(), schemaDefinitionAppender, schemaResolver);
}
propertyTypeDescription.ApplyType(jsonProperty);
var propertyName = JsonPathUtilities.GetPropertyName(property);
parentSchema.Properties.Add(propertyName, jsonProperty);
var requiredAttribute = TryGetAttribute(attributes, "System.ComponentModel.DataAnnotations.RequiredAttribute");
var jsonPropertyAttribute = property.GetCustomAttribute <JsonPropertyAttribute>();
var hasJsonNetAttributeRequired = jsonPropertyAttribute != null && (
jsonPropertyAttribute.Required == Required.Always ||
jsonPropertyAttribute.Required == Required.AllowNull);
var hasRequiredAttribute = requiredAttribute != null;
if (hasRequiredAttribute || hasJsonNetAttributeRequired)
{
parentSchema.RequiredProperties.Add(propertyName);
}
var isJsonNetAttributeNullable = jsonPropertyAttribute != null && jsonPropertyAttribute.Required == Required.AllowNull;
var isNullable = propertyTypeDescription.IsAlwaysRequired == false;
if (!hasRequiredAttribute && (isNullable || isJsonNetAttributeNullable))
{
jsonProperty.Type = jsonProperty.Type | JsonObjectType.Null;
}
dynamic readOnlyAttribute = TryGetAttribute(attributes, "System.ComponentModel.ReadOnlyAttribute");
if (readOnlyAttribute != null)
{
jsonProperty.IsReadOnly = readOnlyAttribute.IsReadOnly;
}
jsonProperty.Description = GetDescription(property, attributes);
ApplyPropertyAnnotations(jsonProperty, attributes, propertyTypeDescription);
}
}
private JsonConverter GetConverter(JsonContract contract, JsonConverter memberConverter, JsonContainerContract containerContract, JsonProperty containerProperty)
{
JsonConverter converter = null;
if (memberConverter != null)
{
// member attribute converter
converter = memberConverter;
}
else if (containerProperty != null && containerProperty.ItemConverter != null)
{
converter = containerProperty.ItemConverter;
}
else if (containerContract != null && containerContract.ItemConverter != null)
{
converter = containerContract.ItemConverter;
}
else if (contract != null)
{
JsonConverter matchingConverter;
if (contract.Converter != null)
// class attribute converter
converter = contract.Converter;
else if ((matchingConverter = Serializer.GetMatchingConverter(contract.UnderlyingType)) != null)
// passed in converters
converter = matchingConverter;
else if (contract.InternalConverter != null)
// internally specified converter
converter = contract.InternalConverter;
}
return converter;
}
public static PropertyInfo PropertyInfo(this JsonProperty jsonProperty)
{
return(jsonProperty.DeclaringType.GetProperty(jsonProperty.UnderlyingName, jsonProperty.PropertyType));
}
private bool IsDataProperty(JsonProperty property) {
return (typeof(IData).IsAssignableFrom(property.DeclaringType)
&& property.PropertyType == typeof(DataDictionary)
&& property.PropertyName == "Data");
}
public static string GetSimpleOrComplexPropertyName(this JsonProperty property)
{
return((property as EntityJsonProperty)?.SimplePropertyName ?? property.PropertyName);
}
public string Generate(JsonProperty property)
{
return("MyCustom" + ConversionUtilities.ConvertToUpperCamelCase(property.Name, true));
}
public static string GetComplexOrSimpleUnderlyingName(this JsonProperty property)
{
return((property as EntityJsonProperty)?.ComplexUnderlyingName ?? property.UnderlyingName);
}
private bool ShouldWriteType(TypeNameHandling typeNameHandlingFlag, JsonContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerProperty)
{
TypeNameHandling resolvedTypeNameHandling =
((member != null) ? member.TypeNameHandling : null)
?? ((containerProperty != null) ? containerProperty.ItemTypeNameHandling : null)
?? ((containerContract != null) ? containerContract.ItemTypeNameHandling : null)
?? Serializer._typeNameHandling;
if (HasFlag(resolvedTypeNameHandling, typeNameHandlingFlag))
return true;
// instance type and the property's type's contract default type are different (no need to put the type in JSON because the type will be created by default)
if (HasFlag(resolvedTypeNameHandling, TypeNameHandling.Auto))
{
if (member != null)
{
if (contract.UnderlyingType != member.PropertyContract.CreatedType)
return true;
}
else if (containerContract != null)
{
if (containerContract.ItemContract == null || contract.UnderlyingType != containerContract.ItemContract.CreatedType)
return true;
}
else if (_rootContract != null && _serializeStack.Count == _rootLevel)
{
if (contract.UnderlyingType != _rootContract.CreatedType)
return true;
}
}
return false;
}
static void WriteDefaultValuesForType(Type type, JsonWriter writer, JsonSerializer serializer, JsonProperty parent, int depth)
{
var contract = serializer.ContractResolver.ResolveContract(type);
var defaultValue = parent?.DefaultValue;
if (defaultValue == null && type.IsValueType && Nullable.GetUnderlyingType(type) == null)
{
defaultValue = contract.DefaultCreator();
}
if (contract is JsonPrimitiveContract primitive)
{
serializer.Serialize(writer, defaultValue);
}
else if (contract is JsonObjectContract obj)
{
if (depth > 0 && defaultValue == null)
{
writer.WriteNull();
}
else
{
writer.WriteStartObject();
foreach (var p in obj.Properties)
{
writer.WritePropertyName(p.PropertyName);
WriteDefaultValuesForType(p.PropertyType, writer, serializer, p, depth++);
}
writer.WriteEndObject();
}
}
else if (contract is JsonArrayContract array)
{
writer.WriteStartArray();
writer.WriteEndArray();
}
else if (contract is JsonDictionaryContract dict)
{
if (depth > 0 && defaultValue == null)
{
writer.WriteNull();
}
else
{
writer.WriteStartObject();
writer.WriteEndObject();
}
}
else if (contract is Newtonsoft.Json.Serialization.JsonLinqContract linq)
{
/* What to do here? */
writer.WriteNull();
}
else
{
//JsonISerializableContract, JsonDynamicContract,
throw new JsonSerializationException(string.Format("Unsupported contract {0}", contract));
}
}
/// <summary>
/// Parses a property starting with the colon after the property name.
/// </summary>
/// <param name="propertyName">The name of the property.</param>
/// <param name="propertyNameTextAnnotation">The name text annotation for the property.</param>
/// <returns>parsed object</returns>
private JsonProperty ParsePropertyWithName(string propertyName, JsonPropertyNameTextAnnotation propertyNameTextAnnotation)
{
// Each name is followed by : (colon)
ExceptionUtilities.Assert(this.tokenizer.TokenType == JsonTokenType.Colon, "Invalid Token");
var nameValueSeparatorTextAnnotation = new JsonPropertyNameValueSeparatorTextAnnotation() { Text = this.tokenizer.TokenText };
this.tokenizer.GetNextToken();
// Colon is followed by a value
ExceptionUtilities.Assert(this.IsValueType(this.tokenizer.TokenType), "Invalid Token");
JsonValue value = this.ParseValue();
var property = new JsonProperty(propertyName, value);
property.SetAnnotation(propertyNameTextAnnotation);
property.SetAnnotation(nameValueSeparatorTextAnnotation);
return property;
}
internal static Schema AssignValidationProperties(this Schema schema, JsonProperty jsonProperty)
{
var propInfo = jsonProperty.PropertyInfo();
if (propInfo == null)
{
return(schema);
}
foreach (var attribute in propInfo.GetCustomAttributes(false))
{
var defaultValue = attribute as DefaultValueAttribute;
if (defaultValue != null)
{
schema.Default = defaultValue.Value;
}
var regex = attribute as RegularExpressionAttribute;
if (regex != null)
{
schema.Pattern = regex.Pattern;
}
var range = attribute as RangeAttribute;
if (range != null)
{
int maximum;
if (Int32.TryParse(range.Maximum.ToString(), out maximum))
{
schema.Maximum = maximum;
}
int minimum;
if (Int32.TryParse(range.Minimum.ToString(), out minimum))
{
schema.Minimum = minimum;
}
}
var minLength = attribute as MinLengthAttribute;
if (minLength != null)
{
schema.MinLength = minLength.Length;
}
var maxLength = attribute as MaxLengthAttribute;
if (maxLength != null)
{
schema.MaxLength = maxLength.Length;
}
var stringLength = attribute as StringLengthAttribute;
if (stringLength != null)
{
schema.MinLength = stringLength.MinimumLength;
schema.MaxLength = stringLength.MaximumLength;
}
}
if (!jsonProperty.Writable)
{
schema.ReadOnly = true;
}
return(schema);
}
private bool ShouldSetPropertyValue(JsonProperty property, object value)
{
if (property.NullValueHandling.GetValueOrDefault(Serializer._nullValueHandling) == NullValueHandling.Ignore && value == null)
return false;
if (HasFlag(property.DefaultValueHandling.GetValueOrDefault(Serializer._defaultValueHandling), DefaultValueHandling.Ignore)
&& !HasFlag(property.DefaultValueHandling.GetValueOrDefault(Serializer._defaultValueHandling), DefaultValueHandling.Populate)
&& MiscellaneousUtils.ValueEquals(value, property.GetResolvedDefaultValue()))
return false;
if (!property.Writable)
return false;
return true;
}
/// <summary>
/// Initializes a new instance.
/// </summary>
public JsonPatchProperty([NotNull] JsonProperty property, [NotNull] object parent)
{
Property = property;
Parent = parent;
}
private object PopulateMultidimensionalArray(IList list, JsonReader reader, JsonArrayContract contract, JsonProperty containerProperty, string id)
{
int rank = contract.UnderlyingType.GetArrayRank();
if (id != null)
AddReference(reader, id, list);
OnDeserializing(reader, contract, list);
JsonContract collectionItemContract = GetContractSafe(contract.CollectionItemType);
JsonConverter collectionItemConverter = GetConverter(collectionItemContract, null, contract, containerProperty);
int? previousErrorIndex = null;
Stack<IList> listStack = new Stack<IList>();
listStack.Push(list);
IList currentList = list;
bool finished = false;
do
{
int initialDepth = reader.Depth;
if (listStack.Count == rank)
{
try
{
if (ReadForType(reader, collectionItemContract, collectionItemConverter != null))
{
switch (reader.TokenType)
{
case JsonToken.EndArray:
listStack.Pop();
currentList = listStack.Peek();
previousErrorIndex = null;
break;
case JsonToken.Comment:
break;
default:
object value;
if (collectionItemConverter != null && collectionItemConverter.CanRead)
value = DeserializeConvertable(collectionItemConverter, reader, contract.CollectionItemType, null);
else
value = CreateValueInternal(reader, contract.CollectionItemType, collectionItemContract, null, contract, containerProperty, null);
currentList.Add(value);
break;
}
}
else
{
break;
}
}
catch (Exception ex)
{
JsonPosition errorPosition = reader.GetPosition(initialDepth);
if (IsErrorHandled(list, contract, errorPosition.Position, reader as IJsonLineInfo, reader.Path, ex))
{
HandleError(reader, true, initialDepth);
if (previousErrorIndex != null && previousErrorIndex == errorPosition.Position)
{
// reader index has not moved since previous error handling
// break out of reading array to prevent infinite loop
throw JsonSerializationException.Create(reader, "Infinite loop detected from error handling.", ex);
}
else
{
previousErrorIndex = errorPosition.Position;
}
}
else
{
throw;
}
}
}
else
{
if (reader.Read())
{
switch (reader.TokenType)
{
case JsonToken.StartArray:
IList newList = new List<object>();
currentList.Add(newList);
listStack.Push(newList);
currentList = newList;
break;
case JsonToken.EndArray:
listStack.Pop();
if (listStack.Count > 0)
{
currentList = listStack.Peek();
}
else
{
finished = true;
}
break;
case JsonToken.Comment:
break;
default:
throw JsonSerializationException.Create(reader, "Unexpected token when deserializing multidimensional array: " + reader.TokenType);
}
}
else
{
break;
}
}
} while (!finished);
if (!finished)
ThrowUnexpectedEndException(reader, contract, list, "Unexpected end when deserializing array.");
OnDeserialized(reader, contract, list);
return list;
}
static bool IsIgnored(JsonProperty property)
{
return(property.Ignored || !property.Readable || !property.Writable);
}
private object CreateISerializable(JsonReader reader, JsonISerializableContract contract, JsonProperty member, string id)
{
Type objectType = contract.UnderlyingType;
if (!JsonTypeReflector.FullyTrusted)
{
string message = @"Type '{0}' implements ISerializable but cannot be deserialized using the ISerializable interface because the current application is not fully trusted and ISerializable can expose secure data." + Environment.NewLine +
@"To fix this error either change the environment to be fully trusted, change the application to not deserialize the type, add JsonObjectAttribute to the type or change the JsonSerializer setting ContractResolver to use a new DefaultContractResolver with IgnoreSerializableInterface set to true." + Environment.NewLine;
message = message.FormatWith(CultureInfo.InvariantCulture, objectType);
throw JsonSerializationException.Create(reader, message);
}
if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Info)
TraceWriter.Trace(TraceLevel.Info, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "Deserializing {0} using ISerializable constructor.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType)), null);
SerializationInfo serializationInfo = new SerializationInfo(contract.UnderlyingType, GetFormatterConverter());
bool finished = false;
do
{
switch (reader.TokenType)
{
case JsonToken.PropertyName:
string memberName = reader.Value.ToString();
if (!reader.Read())
throw JsonSerializationException.Create(reader, "Unexpected end when setting {0}'s value.".FormatWith(CultureInfo.InvariantCulture, memberName));
if (reader.TokenType == JsonToken.StartObject)
{
// this will read any potential type names embedded in json
object o = CreateObject(reader, null, null, null, contract, member, null);
serializationInfo.AddValue(memberName, o);
}
else
{
serializationInfo.AddValue(memberName, JToken.ReadFrom(reader));
}
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, serializationInfo, "Unexpected end when deserializing object.");
if (contract.ISerializableCreator == null)
throw JsonSerializationException.Create(reader, "ISerializable type '{0}' does not have a valid constructor. To correctly implement ISerializable a constructor that takes SerializationInfo and StreamingContext parameters should be present.".FormatWith(CultureInfo.InvariantCulture, objectType));
object createdObject = contract.ISerializableCreator(serializationInfo, Serializer._context);
if (id != null)
AddReference(reader, id, createdObject);
// these are together because OnDeserializing takes an object but for an ISerializable the object is fully created in the constructor
OnDeserializing(reader, contract, createdObject);
OnDeserialized(reader, contract, createdObject);
return createdObject;
}
static bool ShouldSkip(JsonProperty property)
{
return(property.Ignored || !property.Readable || !property.Writable);
}
private object CreateObjectUsingCreatorWithParameters(JsonReader reader, JsonObjectContract contract, JsonProperty containerProperty, ObjectConstructor<object> creator, string id)
{
ValidationUtils.ArgumentNotNull(creator, "creator");
// only need to keep a track of properies presence if they are required or a value should be defaulted if missing
Dictionary<JsonProperty, PropertyPresence> propertiesPresence = (contract.HasRequiredOrDefaultValueProperties || HasFlag(Serializer._defaultValueHandling, DefaultValueHandling.Populate))
? contract.Properties.ToDictionary(m => m, m => PropertyPresence.None)
: null;
Type objectType = contract.UnderlyingType;
if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Info)
{
string parameters = string.Join(", ", contract.CreatorParameters.Select(p => p.PropertyName).ToArray());
TraceWriter.Trace(TraceLevel.Info, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "Deserializing {0} using creator with parameters: {1}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType, parameters)), null);
}
IDictionary<string, object> extensionData;
IDictionary<JsonProperty, object> propertyValues = ResolvePropertyAndCreatorValues(contract, containerProperty, reader, objectType, out extensionData);
object[] creatorParameterValues = new object[contract.CreatorParameters.Count];
IDictionary<JsonProperty, object> remainingPropertyValues = new Dictionary<JsonProperty, object>();
foreach (KeyValuePair<JsonProperty, object> propertyValue in propertyValues)
{
JsonProperty property = propertyValue.Key;
JsonProperty matchingCreatorParameter;
if (contract.CreatorParameters.Contains(property))
{
matchingCreatorParameter = property;
}
else
{
// check to see if a parameter with the same name as the underlying property name exists and match to that
matchingCreatorParameter = contract.CreatorParameters.ForgivingCaseSensitiveFind(p => p.PropertyName, property.UnderlyingName);
}
if (matchingCreatorParameter != null)
{
int i = contract.CreatorParameters.IndexOf(matchingCreatorParameter);
creatorParameterValues[i] = propertyValue.Value;
}
else
{
remainingPropertyValues.Add(propertyValue);
}
if (propertiesPresence != null)
{
// map from creator property to normal property
JsonProperty presenceProperty = propertiesPresence.Keys.FirstOrDefault(p => p.PropertyName == property.PropertyName);
if (presenceProperty != null)
propertiesPresence[presenceProperty] = (propertyValue.Value == null) ? PropertyPresence.Null : PropertyPresence.Value;
}
}
object createdObject = creator(creatorParameterValues);
if (id != null)
AddReference(reader, id, createdObject);
OnDeserializing(reader, contract, createdObject);
// go through unused values and set the newly created object's properties
foreach (KeyValuePair<JsonProperty, object> remainingPropertyValue in remainingPropertyValues)
{
JsonProperty property = remainingPropertyValue.Key;
object value = remainingPropertyValue.Value;
if (ShouldSetPropertyValue(property, value))
{
property.ValueProvider.SetValue(createdObject, value);
}
else if (!property.Writable && value != null)
{
// handle readonly collection/dictionary properties
JsonContract propertyContract = Serializer._contractResolver.ResolveContract(property.PropertyType);
if (propertyContract.ContractType == JsonContractType.Array)
{
JsonArrayContract propertyArrayContract = (JsonArrayContract)propertyContract;
object createdObjectCollection = property.ValueProvider.GetValue(createdObject);
if (createdObjectCollection != null)
{
IWrappedCollection createdObjectCollectionWrapper = propertyArrayContract.CreateWrapper(createdObjectCollection);
IWrappedCollection newValues = propertyArrayContract.CreateWrapper(value);
foreach (object newValue in newValues)
{
createdObjectCollectionWrapper.Add(newValue);
}
}
}
else if (propertyContract.ContractType == JsonContractType.Dictionary)
{
JsonDictionaryContract dictionaryContract = (JsonDictionaryContract)propertyContract;
object createdObjectDictionary = property.ValueProvider.GetValue(createdObject);
if (createdObjectDictionary != null)
{
IDictionary targetDictionary = (dictionaryContract.ShouldCreateWrapper) ? dictionaryContract.CreateWrapper(createdObjectDictionary) : (IDictionary)createdObjectDictionary;
IDictionary newValues = (dictionaryContract.ShouldCreateWrapper) ? dictionaryContract.CreateWrapper(value) : (IDictionary)value;
foreach (DictionaryEntry newValue in newValues)
{
targetDictionary.Add(newValue.Key, newValue.Value);
}
}
}
}
}
if (extensionData != null)
{
foreach (KeyValuePair<string, object> e in extensionData)
{
contract.ExtensionDataSetter(createdObject, e.Key, e.Value);
}
}
EndObject(createdObject, reader, contract, reader.Depth, propertiesPresence);
OnDeserialized(reader, contract, createdObject);
return createdObject;
}
private static object GenerateJsonObjectFromJsonSchema4(JsonProperty value, List <object> ReferenceStack, bool UseXMlNames)
{
if (CachedValues.ContainsKey(value))
{
object returnValue;
CachedValues.TryGetValue(value, out returnValue);
return(returnValue);
}
if (ReferenceStack == null)
{
ReferenceStack = new List <object>();
}
List <object> PrivateStack = new List <object>();
object output = "";
switch (value.Type)
{
case JsonObjectType.Object:
Dictionary <string, object> JsonBody = new Dictionary <string, object>();
foreach (KeyValuePair <string, JsonProperty> jkp in value.ActualProperties)
{
string key = jkp.Key;
if (UseXMlNames && jkp.Value.Xml != null)
{
key = jkp.Value.Xml.Name;
}
ReferenceStack.Add(jkp.Value);
PrivateStack.Add(jkp.Value);
object JObject = GenerateJsonObjectFromJsonSchema4(jkp.Value, ReferenceStack, UseXMlNames);
JsonBody.Add(key, JsonConvert.SerializeObject(JObject));
}
output = JsonBody;
break;
case JsonObjectType.Array:
JObject jb = new JObject();
foreach (var item in value.Item.ActualProperties)
{
string key = item.Key;
if (UseXMlNames && item.Value.Xml != null)
{
key = item.Value.Xml.Name;
}
ReferenceStack.Add(item.Value);
PrivateStack.Add(item.Value);
object JsonObject = GenerateJsonObjectFromJsonSchema4(item.Value, ReferenceStack, UseXMlNames);
jb.Add(key, JsonConvert.SerializeObject(JsonObject));
}
if (value.Item.HasReference)
{
if (!ReferenceStack.Contains(value.Item.Reference))
{
foreach (var item in value.Item.Reference.ActualProperties)
{
if (item.Value.Equals(value))
{
jb.Add(item.Key, "");
}
else
{
string key = item.Key;
if (UseXMlNames && item.Value.Xml != null)
{
key = item.Value.Xml.Name;
}
object o = GenerateJsonObjectFromJsonSchema4(item.Value, ReferenceStack, UseXMlNames);
jb.Add(key, (JToken)o);
}
}
}
}
JArray ja = new JArray();
ja.Add(jb);
output = ja;
if (UseXMlNames)
{
Dictionary <string, object> jsb = new Dictionary <string, object>();
jsb.Add(value.Xml.Name, ja);
output = jsb;
}
break;
case JsonObjectType.String:
output = new JValue("sample");
break;
case JsonObjectType.Number:
output = new JValue(1);
break;
case JsonObjectType.Integer:
output = new JValue(1);
break;
case JsonObjectType.Boolean:
output = new JValue(false);
break;
case JsonObjectType.Null:
output = JValue.CreateNull();
break;
default:
output = new JValue("");;
break;
}
foreach (object obj in PrivateStack)
{
ReferenceStack.Remove(obj);
}
CachedValues.Add(value, output);
return(output);
}
public object CreateNewObject(JsonReader reader, JsonObjectContract objectContract, JsonProperty containerMember, JsonProperty containerProperty, string id, out bool createdFromNonDefaultCreator)
{
object newObject = null;
if (objectContract.OverrideCreator != null)
{
if (objectContract.CreatorParameters.Count > 0)
{
createdFromNonDefaultCreator = true;
return CreateObjectUsingCreatorWithParameters(reader, objectContract, containerMember, objectContract.OverrideCreator, id);
}
newObject = objectContract.OverrideCreator(new object[0]);
}
else if (objectContract.DefaultCreator != null &&
(!objectContract.DefaultCreatorNonPublic || Serializer._constructorHandling == ConstructorHandling.AllowNonPublicDefaultConstructor || objectContract.ParametrizedCreator == null))
{
// use the default constructor if it is...
// public
// non-public and the user has change constructor handling settings
// non-public and there is no other creator
newObject = objectContract.DefaultCreator();
}
else if (objectContract.ParametrizedCreator != null)
{
createdFromNonDefaultCreator = true;
return CreateObjectUsingCreatorWithParameters(reader, objectContract, containerMember, objectContract.ParametrizedCreator, id);
}
if (newObject == null)
{
if (!objectContract.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, objectContract.UnderlyingType));
throw JsonSerializationException.Create(reader, "Unable to find a constructor to use for type {0}. A class should either have a default constructor, one constructor with arguments or a constructor marked with the JsonConstructor attribute.".FormatWith(CultureInfo.InvariantCulture, objectContract.UnderlyingType));
}
createdFromNonDefaultCreator = false;
return newObject;
}
private bool ReadMetadataPropertiesToken(JTokenReader reader, ref Type objectType, ref JsonContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerMember, object existingValue, out object newValue, out string id)
{
id = null;
newValue = null;
if (reader.TokenType == JsonToken.StartObject)
{
JObject current = (JObject)reader._current;
JToken refToken = current[JsonTypeReflector.RefPropertyName];
if (refToken != null)
{
if (refToken.Type != JTokenType.String && refToken.Type != JTokenType.Null)
throw JsonSerializationException.Create(refToken, refToken.Path, "JSON reference {0} property must have a string or null value.".FormatWith(CultureInfo.InvariantCulture, JsonTypeReflector.RefPropertyName), null);
JToken property = refToken.Parent;
JToken additionalContent = null;
if (property.Next != null)
additionalContent = property.Next;
else if (property.Previous != null)
additionalContent = property.Previous;
string reference = (string)refToken;
if (reference != null)
{
if (additionalContent != null)
throw JsonSerializationException.Create(additionalContent, additionalContent.Path, "Additional content found in JSON reference object. A JSON reference object should only have a {0} property.".FormatWith(CultureInfo.InvariantCulture, JsonTypeReflector.RefPropertyName), null);
newValue = Serializer.GetReferenceResolver().ResolveReference(this, reference);
if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Info)
TraceWriter.Trace(TraceLevel.Info, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "Resolved object reference '{0}' to {1}.".FormatWith(CultureInfo.InvariantCulture, reference, newValue.GetType())), null);
reader.Skip();
return true;
}
}
JToken typeToken = current[JsonTypeReflector.TypePropertyName];
if (typeToken != null)
{
string qualifiedTypeName = (string)typeToken;
JsonReader typeTokenReader = typeToken.CreateReader();
CheckedRead(typeTokenReader);
ResolveTypeName(typeTokenReader, ref objectType, ref contract, member, containerContract, containerMember, qualifiedTypeName);
JToken valueToken = current[JsonTypeReflector.ValuePropertyName];
if (valueToken != null)
{
while (true)
{
CheckedRead(reader);
if (reader.TokenType == JsonToken.PropertyName)
{
if ((string)reader.Value == JsonTypeReflector.ValuePropertyName)
return false;
}
CheckedRead(reader);
reader.Skip();
}
}
}
JToken idToken = current[JsonTypeReflector.IdPropertyName];
if (idToken != null)
{
id = (string)idToken;
}
JToken valuesToken = current[JsonTypeReflector.ArrayValuesPropertyName];
if (valuesToken != null)
{
JsonReader listReader = valuesToken.CreateReader();
CheckedRead(listReader);
newValue = CreateList(listReader, objectType, contract, member, existingValue, id);
reader.Skip();
return true;
}
}
CheckedRead(reader);
return false;
}
private void SetExtensionData(JsonObjectContract contract, JsonProperty member, JsonReader reader, string memberName, object o)
{
if (contract.ExtensionDataSetter != null)
{
try
{
object value = CreateValueInternal(reader, null, null, null, contract, member, null);
contract.ExtensionDataSetter(o, memberName, value);
}
catch (Exception ex)
{
throw JsonSerializationException.Create(reader, "Error setting value in extension data for type '{0}'.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType), ex);
}
}
else
{
reader.Skip();
}
}
private void ResolveTypeName(JsonReader reader, ref Type objectType, ref JsonContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerMember, string qualifiedTypeName)
{
TypeNameHandling resolvedTypeNameHandling =
((member != null) ? member.TypeNameHandling : null)
?? ((containerContract != null) ? containerContract.ItemTypeNameHandling : null)
?? ((containerMember != null) ? containerMember.ItemTypeNameHandling : null)
?? Serializer._typeNameHandling;
if (resolvedTypeNameHandling != 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 JsonSerializationException.Create(reader, "Error resolving type specified in JSON '{0}'.".FormatWith(CultureInfo.InvariantCulture, qualifiedTypeName), ex);
}
if (specifiedType == null)
throw JsonSerializationException.Create(reader, "Type specified in JSON '{0}' was not resolved.".FormatWith(CultureInfo.InvariantCulture, qualifiedTypeName));
if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
TraceWriter.Trace(TraceLevel.Verbose, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "Resolved type '{0}' to {1}.".FormatWith(CultureInfo.InvariantCulture, qualifiedTypeName, specifiedType)), null);
if (objectType != null
#if !(NET35 || NET20 || PORTABLE40)
&& objectType != typeof(IDynamicMetaObjectProvider)
#endif
&& !objectType.IsAssignableFrom(specifiedType))
throw JsonSerializationException.Create(reader, "Type specified in JSON '{0}' is not compatible with '{1}'.".FormatWith(CultureInfo.InvariantCulture, specifiedType.AssemblyQualifiedName, objectType.AssemblyQualifiedName));
objectType = specifiedType;
contract = GetContractSafe(specifiedType);
}
}
private object CreateValueInternal(JsonReader reader, Type objectType, JsonContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerMember, object existingValue)
{
if (contract != null && contract.ContractType == JsonContractType.Linq)
return CreateJToken(reader, contract);
do
{
switch (reader.TokenType)
{
// populate a typed object or generic dictionary/array
// depending upon whether an objectType was supplied
case JsonToken.StartObject:
return CreateObject(reader, objectType, contract, member, containerContract, containerMember, existingValue);
case JsonToken.StartArray:
return CreateList(reader, objectType, contract, member, existingValue, null);
case JsonToken.Integer:
case JsonToken.Float:
case JsonToken.Boolean:
case JsonToken.Date:
case JsonToken.Bytes:
return EnsureType(reader, reader.Value, CultureInfo.InvariantCulture, contract, objectType);
case JsonToken.String:
string s = (string)reader.Value;
// convert empty string to null automatically for nullable types
if (string.IsNullOrEmpty(s) && objectType != typeof(string) && objectType != typeof(object) && contract != null && contract.IsNullable)
return null;
// string that needs to be returned as a byte array should be base 64 decoded
if (objectType == typeof(byte[]))
return Convert.FromBase64String(s);
return EnsureType(reader, s, CultureInfo.InvariantCulture, contract, objectType);
case JsonToken.StartConstructor:
string constructorName = reader.Value.ToString();
return EnsureType(reader, constructorName, CultureInfo.InvariantCulture, contract, objectType);
case JsonToken.Null:
case JsonToken.Undefined:
#if !(NETFX_CORE || PORTABLE40 || PORTABLE)
if (objectType == typeof(DBNull))
return DBNull.Value;
#endif
return EnsureType(reader, reader.Value, CultureInfo.InvariantCulture, contract, objectType);
case JsonToken.Raw:
return new JRaw((string)reader.Value);
case JsonToken.Comment:
// ignore
break;
default:
throw JsonSerializationException.Create(reader, "Unexpected token while deserializing object: " + reader.TokenType);
}
} while (reader.Read());
throw JsonSerializationException.Create(reader, "Unexpected end when deserializing object.");
}
private bool SetPropertyValue(JsonProperty property, JsonConverter propertyConverter, JsonContainerContract containerContract, JsonProperty containerProperty, JsonReader reader, object target)
{
object currentValue;
bool useExistingValue;
JsonContract propertyContract;
bool gottenCurrentValue;
if (CalculatePropertyDetails(property, ref propertyConverter, containerContract, containerProperty, reader, target, out useExistingValue, out currentValue, out propertyContract, out gottenCurrentValue))
return false;
object value;
if (propertyConverter != null && propertyConverter.CanRead)
{
if (!gottenCurrentValue && target != null && property.Readable)
currentValue = property.ValueProvider.GetValue(target);
value = DeserializeConvertable(propertyConverter, reader, property.PropertyType, currentValue);
}
else
{
value = CreateValueInternal(reader, property.PropertyType, propertyContract, property, containerContract, containerProperty, (useExistingValue) ? currentValue : null);
}
// always set the value if useExistingValue is false,
// otherwise also set it if CreateValue returns a new value compared to the currentValue
// this could happen because of a JsonConverter against the type
if ((!useExistingValue || value != currentValue)
&& ShouldSetPropertyValue(property, value))
{
property.ValueProvider.SetValue(target, value);
if (property.SetIsSpecified != null)
{
if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Verbose)
TraceWriter.Trace(TraceLevel.Verbose, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "IsSpecified for property '{0}' on {1} set to true.".FormatWith(CultureInfo.InvariantCulture, property.PropertyName, property.DeclaringType)), null);
property.SetIsSpecified(target, true);
}
return true;
}
// the value wasn't set be JSON was populated onto the existing value
return useExistingValue;
}
internal static bool IsRequired(this JsonProperty jsonProperty)
{
return(jsonProperty.Required == Newtonsoft.Json.Required.AllowNull ||
jsonProperty.Required == Newtonsoft.Json.Required.Always ||
jsonProperty.HasAttribute <RequiredAttribute>());
}
protected override IList <JsonProperty> CreateProperties(Type type, MemberSerialization memberSerialization)
{
var properties = new List <JsonProperty>(base.CreateProperties(type, memberSerialization));
var hasOneAdIdProperties = new List <JsonProperty>();
properties.RemoveAll((prop) => {
// do not attempt to (de)serialize IHasManys
if (prop.PropertyType.IsGenericType && prop.PropertyType.GetGenericTypeDefinition() == typeof(IHasMany <>))
{
return(true);
}
// if we're (de)serializing the top-level Container object, perform our wrapper-object
// name transformation
if (type.IsGenericType && type.GetGenericTypeDefinition() == typeof(Container <>))
{
// our Container type only has one property (the specially named per-resource property),
// so, we just presume to match all properties in Container.
prop.PropertyName = ResourceName;
return(false);
}
// is property a HasOne?
if (prop.PropertyType.IsGenericType && prop.PropertyType.GetGenericTypeDefinition() == typeof(IHasOne <>))
{
var underscorized = ShopifyAPIContext.Underscoreify(prop.PropertyName);
// get type argument of IHasOne
var hasOneTargetType = prop.PropertyType.GetGenericArguments();
// I was really hoping to avoid activator.createinstance... :(
Type hasOneInlineConverterType = typeof(HasOneInlineJsonConverter <>).MakeGenericType(hasOneTargetType);
var hasOneInlineConverter = Activator.CreateInstance(hasOneInlineConverterType);
Type hasOneAsIdConverterType = typeof(HasOneAsIdJsonConverter <>).MakeGenericType(hasOneTargetType);
var hasOneAsIdConverter = Activator.CreateInstance(hasOneAsIdConverterType);
// set the standard HasOneConverter
// TODO if we can de-genericify hasOneConverter, just set it up globally and get rid of this dynamic instantiation
prop.Converter = (JsonConverter)hasOneInlineConverter;
prop.MemberConverter = (JsonConverter)hasOneInlineConverter;
// create an additional property for the as-id deserialization (deserialization *only*) case
JsonProperty asIdProperty = new JsonProperty()
{
PropertyType = prop.PropertyType,
Ignored = false,
PropertyName = underscorized + "_id",
UnderlyingName = prop.UnderlyingName,
DeclaringType = prop.DeclaringType,
ValueProvider = prop.ValueProvider,
Readable = true,
Writable = true,
// Use the as-id converter
Converter = (JsonConverter)hasOneAsIdConverter,
MemberConverter = (JsonConverter)hasOneAsIdConverter
};
// make props:
// outgoing inline
// outgoing as id
// incoming inline
// incoming as id
// the outgoings should have ShouldSerializes that do the HasOne type check IN addition to the usual dirty check
// the incomings can be naiive, since the presence of either field in the incoming json makes the selection
// we should only serialize such properties as have changed.
prop.ShouldSerialize = (obj) =>
{
// TODO: https://trello.com/card/isfielddirty-if-called-on-inline-hasone-fields-should-return-true-if-the-contained-resource-model-is-at-all-dirty/50a1c9c990c4980e0600178b/58
var hasOneInstance = prop.ValueProvider.GetValue(obj);
if ((hasOneInstance as IHasOneInlineUntyped) == null)
{
return(false);
}
IResourceModel model = (IResourceModel)obj;
return(model.IsFieldDirty(prop.UnderlyingName));
};
asIdProperty.ShouldSerialize = (obj) =>
{
var hasOneInstance = prop.ValueProvider.GetValue(obj);
if ((hasOneInstance as IHasOneAsIdUntyped) == null)
{
return(false);
}
IResourceModel model = (IResourceModel)obj;
return(model.IsFieldDirty(asIdProperty.UnderlyingName));
};
// we add all of the created as=id property descriptors after,
// in order to avoid modifying the collection while RemoveAll is
// running
hasOneAdIdProperties.Add(asIdProperty);
return(false);
}
if (typeof(IGranularDirtiable).IsAssignableFrom(type))
{
// the main ID field should always be included
if (prop.PropertyName != "id")
{
prop.ShouldSerialize = (obj) =>
{
IGranularDirtiable model = (IGranularDirtiable)obj;
return(model.IsFieldDirty(prop.UnderlyingName));
};
}
}
return(false);
});
properties.AddRange(hasOneAdIdProperties);
return(properties);
}
private bool ReadMetadataProperties(JsonReader reader, ref Type objectType, ref JsonContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerMember, object existingValue, out object newValue, out string id)
{
id = null;
newValue = null;
if (reader.TokenType == JsonToken.PropertyName)
{
string propertyName = reader.Value.ToString();
if (propertyName.Length > 0 && propertyName[0] == '$')
{
// read metadata properties
// $type, $id, $ref, etc
bool metadataProperty;
do
{
propertyName = reader.Value.ToString();
if (string.Equals(propertyName, JsonTypeReflector.RefPropertyName, StringComparison.Ordinal))
{
CheckedRead(reader);
if (reader.TokenType != JsonToken.String && reader.TokenType != JsonToken.Null)
throw JsonSerializationException.Create(reader, "JSON reference {0} property must have a string or null value.".FormatWith(CultureInfo.InvariantCulture, JsonTypeReflector.RefPropertyName));
string reference = (reader.Value != null) ? reader.Value.ToString() : null;
CheckedRead(reader);
if (reference != null)
{
if (reader.TokenType == JsonToken.PropertyName)
throw JsonSerializationException.Create(reader, "Additional content found in JSON reference object. A JSON reference object should only have a {0} property.".FormatWith(CultureInfo.InvariantCulture, JsonTypeReflector.RefPropertyName));
newValue = Serializer.GetReferenceResolver().ResolveReference(this, reference);
if (TraceWriter != null && TraceWriter.LevelFilter >= TraceLevel.Info)
TraceWriter.Trace(TraceLevel.Info, JsonPosition.FormatMessage(reader as IJsonLineInfo, reader.Path, "Resolved object reference '{0}' to {1}.".FormatWith(CultureInfo.InvariantCulture, reference, newValue.GetType())), null);
return true;
}
else
{
metadataProperty = true;
}
}
else if (string.Equals(propertyName, JsonTypeReflector.TypePropertyName, StringComparison.Ordinal))
{
CheckedRead(reader);
string qualifiedTypeName = reader.Value.ToString();
ResolveTypeName(reader, ref objectType, ref contract, member, containerContract, containerMember, qualifiedTypeName);
CheckedRead(reader);
metadataProperty = true;
}
else if (string.Equals(propertyName, JsonTypeReflector.IdPropertyName, StringComparison.Ordinal))
{
CheckedRead(reader);
id = (reader.Value != null) ? reader.Value.ToString() : null;
CheckedRead(reader);
metadataProperty = true;
}
else if (string.Equals(propertyName, JsonTypeReflector.ArrayValuesPropertyName, StringComparison.Ordinal))
{
CheckedRead(reader);
object list = CreateList(reader, objectType, contract, member, existingValue, id);
CheckedRead(reader);
newValue = list;
return true;
}
else
{
metadataProperty = false;
}
} while (metadataProperty && reader.TokenType == JsonToken.PropertyName);
}
}
return false;
}
internal static bool IsObsolete(this JsonProperty jsonProperty)
{
return(jsonProperty.HasAttribute <ObsoleteAttribute>());
}
private object CreateList(JsonReader reader, Type objectType, JsonContract contract, JsonProperty member, object existingValue, string id)
{
object value;
if (HasNoDefinedType(contract))
return CreateJToken(reader, contract);
JsonArrayContract arrayContract = EnsureArrayContract(reader, objectType, contract);
if (existingValue == null)
{
bool createdFromNonDefaultCreator;
IList list = CreateNewList(reader, arrayContract, out createdFromNonDefaultCreator);
if (createdFromNonDefaultCreator)
{
if (id != null)
throw JsonSerializationException.Create(reader, "Cannot preserve reference to array or readonly list, or list created from a non-default constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
if (contract.OnSerializingCallbacks.Count > 0)
throw JsonSerializationException.Create(reader, "Cannot call OnSerializing on an array or readonly list, or list created from a non-default constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
if (contract.OnErrorCallbacks.Count > 0)
throw JsonSerializationException.Create(reader, "Cannot call OnError on an array or readonly list, or list created from a non-default constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
if (!arrayContract.HasParametrizedCreator && !arrayContract.IsArray)
throw JsonSerializationException.Create(reader, "Cannot deserialize readonly or fixed size list: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
}
if (!arrayContract.IsMultidimensionalArray)
PopulateList(list, reader, arrayContract, member, id);
else
PopulateMultidimensionalArray(list, reader, arrayContract, member, id);
if (createdFromNonDefaultCreator)
{
if (arrayContract.IsMultidimensionalArray)
{
list = CollectionUtils.ToMultidimensionalArray(list, arrayContract.CollectionItemType, contract.CreatedType.GetArrayRank());
}
else if (arrayContract.IsArray)
{
Array a = Array.CreateInstance(arrayContract.CollectionItemType, list.Count);
list.CopyTo(a, 0);
list = a;
}
else
{
// call constructor that takes IEnumerable<T>
return arrayContract.ParametrizedCreator(list);
}
}
else if (list is IWrappedCollection)
{
return ((IWrappedCollection)list).UnderlyingCollection;
}
value = list;
}
else
{
value = PopulateList((arrayContract.ShouldCreateWrapper) ? arrayContract.CreateWrapper(existingValue) : (IList)existingValue, reader, arrayContract, member, id);
}
return value;
}
private static bool ShouldSerialize(JsonProperty property, object instance)
{
return(property.ShouldSerialize == null || property.ShouldSerialize(instance));
}
private bool CalculatePropertyDetails(JsonProperty property, ref JsonConverter propertyConverter, JsonContainerContract containerContract, JsonProperty containerProperty, JsonReader reader, object target, out bool useExistingValue, out object currentValue, out JsonContract propertyContract, out bool gottenCurrentValue)
{
currentValue = null;
useExistingValue = false;
propertyContract = null;
gottenCurrentValue = false;
if (property.Ignored)
return true;
JsonToken tokenType = reader.TokenType;
if (property.PropertyContract == null)
property.PropertyContract = GetContractSafe(property.PropertyType);
ObjectCreationHandling objectCreationHandling =
property.ObjectCreationHandling.GetValueOrDefault(Serializer._objectCreationHandling);
if ((objectCreationHandling != ObjectCreationHandling.Replace)
&& (tokenType == JsonToken.StartArray || tokenType == JsonToken.StartObject)
&& property.Readable)
{
currentValue = property.ValueProvider.GetValue(target);
gottenCurrentValue = true;
if (currentValue != null)
{
propertyContract = GetContractSafe(currentValue.GetType());
useExistingValue = (!propertyContract.IsReadOnlyOrFixedSize && !propertyContract.UnderlyingType.IsValueType());
}
}
if (!property.Writable && !useExistingValue)
return true;
// test tokentype here because null might not be convertable to some types, e.g. ignoring null when applied to DateTime
if (property.NullValueHandling.GetValueOrDefault(Serializer._nullValueHandling) == NullValueHandling.Ignore && tokenType == JsonToken.Null)
return true;
// test tokentype here because default value might not be convertable to actual type, e.g. default of "" for DateTime
if (HasFlag(property.DefaultValueHandling.GetValueOrDefault(Serializer._defaultValueHandling), DefaultValueHandling.Ignore)
&& !HasFlag(property.DefaultValueHandling.GetValueOrDefault(Serializer._defaultValueHandling), DefaultValueHandling.Populate)
&& JsonReader.IsPrimitiveToken(tokenType)
&& MiscellaneousUtils.ValueEquals(reader.Value, property.GetResolvedDefaultValue()))
return true;
if (currentValue == null)
{
propertyContract = property.PropertyContract;
}
else
{
propertyContract = GetContractSafe(currentValue.GetType());
if (propertyContract != property.PropertyContract)
propertyConverter = GetConverter(propertyContract, property.MemberConverter, containerContract, containerProperty);
}
return false;
}
private static bool IsNullAndShouldIgnoreNull(JsonProperty property, object propertyValue)
{
return(propertyValue == null && property.NullValueHandling == NullValueHandling.Ignore);
}
/// <summary>
/// Writes a text representation of the specified <paramref name="propertyValue"/> into a text writer.
/// </summary>
/// <param name="propertyValue">The JSON value to write.</param>
private void WriteProperty(JsonProperty propertyValue)
{
var nameTextAnnotation = propertyValue.GetAnnotation<JsonPropertyNameTextAnnotation>()
?? JsonPropertyNameTextAnnotation.GetDefault(propertyValue.Name);
var nameValueSeparatorTextAnnotation = propertyValue.GetAnnotation<JsonPropertyNameValueSeparatorTextAnnotation>()
?? JsonPropertyNameValueSeparatorTextAnnotation.GetDefault();
this.writer.Write(nameTextAnnotation.Text);
this.writer.Write(nameValueSeparatorTextAnnotation.Text);
this.WriteValue(propertyValue.Value);
}
private bool IsDataProperty(JsonProperty property)
{
return(typeof(IData).IsAssignableFrom(property.DeclaringType) &&
property.PropertyType == typeof(DataDictionary) &&
property.PropertyName == "Data");
}
private object CreateObject(JsonReader reader, Type objectType, JsonContract contract, JsonProperty member, JsonContainerContract containerContract, JsonProperty containerMember, object existingValue)
{
string id;
Type resolvedObjectType = objectType;
if (Serializer.MetadataPropertyHandling == MetadataPropertyHandling.Ignore)
{
// don't look for metadata properties
CheckedRead(reader);
id = null;
}
else if (Serializer.MetadataPropertyHandling == MetadataPropertyHandling.ReadAhead)
{
var tokenReader = reader as JTokenReader;
if (tokenReader == null)
{
JToken t = JToken.ReadFrom(reader);
tokenReader = (JTokenReader)t.CreateReader();
tokenReader.Culture = reader.Culture;
tokenReader.DateFormatString = reader.DateFormatString;
tokenReader.DateParseHandling = reader.DateParseHandling;
tokenReader.DateTimeZoneHandling = reader.DateTimeZoneHandling;
tokenReader.FloatParseHandling = reader.FloatParseHandling;
tokenReader.SupportMultipleContent = reader.SupportMultipleContent;
// start
CheckedRead(tokenReader);
reader = tokenReader;
}
object newValue;
if (ReadMetadataPropertiesToken(tokenReader, ref resolvedObjectType, ref contract, member, containerContract, containerMember, existingValue, out newValue, out id))
return newValue;
}
else
{
CheckedRead(reader);
object newValue;
if (ReadMetadataProperties(reader, ref resolvedObjectType, ref contract, member, containerContract, containerMember, existingValue, out newValue, out id))
return newValue;
}
if (HasNoDefinedType(contract))
return CreateJObject(reader);
switch (contract.ContractType)
{
case JsonContractType.Object:
{
bool createdFromNonDefaultCreator = false;
JsonObjectContract objectContract = (JsonObjectContract)contract;
object targetObject;
// check that if type name handling is being used that the existing value is compatible with the specified type
if (existingValue != null && (resolvedObjectType == objectType || resolvedObjectType.IsAssignableFrom(existingValue.GetType())))
targetObject = existingValue;
else
targetObject = CreateNewObject(reader, objectContract, member, containerMember, id, out createdFromNonDefaultCreator);
// don't populate if read from non-default creator because the object has already been read
if (createdFromNonDefaultCreator)
return targetObject;
return PopulateObject(targetObject, reader, objectContract, member, id);
}
case JsonContractType.Primitive:
{
JsonPrimitiveContract primitiveContract = (JsonPrimitiveContract)contract;
// if the content is inside $value then read past it
if (Serializer.MetadataPropertyHandling != MetadataPropertyHandling.Ignore
&& reader.TokenType == JsonToken.PropertyName
&& string.Equals(reader.Value.ToString(), JsonTypeReflector.ValuePropertyName, StringComparison.Ordinal))
{
CheckedRead(reader);
// the token should not be an object because the $type value could have been included in the object
// without needing the $value property
if (reader.TokenType == JsonToken.StartObject)
throw JsonSerializationException.Create(reader, "Unexpected token when deserializing primitive value: " + reader.TokenType);
object value = CreateValueInternal(reader, resolvedObjectType, primitiveContract, member, null, null, existingValue);
CheckedRead(reader);
return value;
}
break;
}
case JsonContractType.Dictionary:
{
JsonDictionaryContract dictionaryContract = (JsonDictionaryContract)contract;
object targetDictionary;
if (existingValue == null)
{
bool createdFromNonDefaultCreator;
IDictionary dictionary = CreateNewDictionary(reader, dictionaryContract, out createdFromNonDefaultCreator);
if (createdFromNonDefaultCreator)
{
if (id != null)
throw JsonSerializationException.Create(reader, "Cannot preserve reference to readonly dictionary, or dictionary created from a non-default constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
if (contract.OnSerializingCallbacks.Count > 0)
throw JsonSerializationException.Create(reader, "Cannot call OnSerializing on readonly dictionary, or dictionary created from a non-default constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
if (contract.OnErrorCallbacks.Count > 0)
throw JsonSerializationException.Create(reader, "Cannot call OnError on readonly list, or dictionary created from a non-default constructor: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
if (!dictionaryContract.HasParametrizedCreator)
throw JsonSerializationException.Create(reader, "Cannot deserialize readonly or fixed size dictionary: {0}.".FormatWith(CultureInfo.InvariantCulture, contract.UnderlyingType));
}
PopulateDictionary(dictionary, reader, dictionaryContract, member, id);
if (createdFromNonDefaultCreator)
{
return dictionaryContract.ParametrizedCreator(dictionary);
}
else if (dictionary is IWrappedDictionary)
{
return ((IWrappedDictionary)dictionary).UnderlyingDictionary;
}
targetDictionary = dictionary;
}
else
{
targetDictionary = PopulateDictionary(dictionaryContract.ShouldCreateWrapper ? dictionaryContract.CreateWrapper(existingValue) : (IDictionary)existingValue, reader, dictionaryContract, member, id);
}
return targetDictionary;
}
#if !(NET35 || NET20 || PORTABLE40)
case JsonContractType.Dynamic:
JsonDynamicContract dynamicContract = (JsonDynamicContract)contract;
return CreateDynamic(reader, dynamicContract, member, id);
#endif
#if !(NETFX_CORE || PORTABLE40 || PORTABLE)
case JsonContractType.Serializable:
JsonISerializableContract serializableContract = (JsonISerializableContract)contract;
return CreateISerializable(reader, serializableContract, member, id);
#endif
}
string message = @"Cannot deserialize the current JSON object (e.g. {{""name"":""value""}}) into type '{0}' because the type requires a {1} to deserialize correctly." + Environment.NewLine +
@"To fix this error either change the JSON to a {1} or change the deserialized type so that it is a normal .NET type (e.g. not a primitive type like integer, not a collection type like an array or List<T>) that can be deserialized from a JSON object. JsonObjectAttribute can also be added to the type to force it to deserialize from a JSON object." + Environment.NewLine;
message = message.FormatWith(CultureInfo.InvariantCulture, resolvedObjectType, GetExpectedDescription(contract));
throw JsonSerializationException.Create(reader, message);
}
