public override void WriteJson(JsonWriter writer, object target, JsonSerializer serializer)
{
writer.WriteStartArray();
var properties = GetOrderedProperties(target);
foreach (var property in properties)
{
var value = new ReflectionValueProvider(property);
if (property.PropertyType == typeof(object[]))
{
var objects = value.GetValue(target) as object[];
if (objects != null)
{
foreach (var v in objects)
{
serializer.Serialize(writer, v);
}
}
}
else if (property.PropertyType == typeof(IEnumerable <Guid>) ||
property.PropertyType == typeof(ISet <Guid>) ||
Nullable.GetUnderlyingType(property.PropertyType) != null)
{
var val = value.GetValue(target);
if (val != null)
{
serializer.Serialize(writer, val);
}
}
else
{
serializer.Serialize(writer, value.GetValue(target));
}
}
writer.WriteEndArray();
}
protected override JsonProperty CreateProperty(MemberInfo member, MemberSerialization serialization)
{
var property = base.CreateProperty(member, serialization);
var valueProvider = property.ValueProvider;
var propertyType = property.PropertyType;
if (propertyType == null || valueProvider == null)
{
return(property);
}
if (member.Name == "Message")
{
if (member.DeclaringType == typeof(ArgumentException))
{
valueProvider = new ReflectionValueProvider(exceptionMessageField);
}
}
if (propertyType.IsException())
{
property.TypeNameHandling = TypeNameHandling.All;
}
if (ignoreEmptyCollections)
{
property.SkipEmptyCollections(member);
}
property.ConfigureIfBool(member, ignoreFalse);
if (ShouldIgnore(member, propertyType, property))
{
property.Ignored = true;
return(property);
}
if (ignoredInstances.TryGetValue(propertyType, out var funcs))
{
property.ShouldSerialize = declaringInstance =>
{
var instance = valueProvider.GetValue(declaringInstance);
if (instance == null)
{
return(false);
}
return(funcs.All(func => !func(instance)));
};
}
ConvertMember?membersConverter = null;
foreach (var pair in membersConverters)
{
if (pair.Key.IsAssignableFrom(property.DeclaringType))
{
pair.Value.TryGetValue(member.Name, out membersConverter);
break;
}
}
property.ValueProvider = new CustomValueProvider(valueProvider, propertyType, ignoreMembersThatThrow, membersConverter);
return(property);
}
public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
{
// Crappy way to do it, but the people who wrote the WAMP spec must have not been
// thinking this all the way through.
// As it's an array, deserializing to any programming object model is a pain in
// the butt.
// We first deserialize to and object array, then we'll set the properties on the
// target object to match
var jsonObject = JArray.Load(reader);
var target = GetType(jsonObject);
var r = jsonObject.CreateReader();
var properties = GetOrderedProperties(target);
// The first item is the opening read marks, so we read past this
if (r.TokenType == JsonToken.None)
{
r.Read();
}
if (r.TokenType != JsonToken.StartArray)
{
throw new JsonSerializationException("Invalid message. Needs to be a JSON Array");
}
foreach (var property in properties)
{
var value = new ReflectionValueProvider(property);
switch (r.TokenType)
{
case JsonToken.None:
case JsonToken.EndArray:
case JsonToken.EndObject:
// Setting the value to null here is like setting it to default(Type) as it internally
// handles Value vs Reference Types
value.SetValue(target, null);
continue;
}
if (!r.Read())
{
throw new JsonSerializationException("Problem deserializing");
}
if (property.PropertyType == typeof(object[]))
{
if (r.TokenType == JsonToken.StartObject)
{
value.SetValue(target, new object[] { serializer.Deserialize <Dictionary <string, object> >(r) });
}
else
{
var objs = new List <object>();
if (r.TokenType != JsonToken.EndArray)
{
objs.Add(GetObjectArrayType(serializer, r));
}
while (r.Read())
{
if (IsWritableTokenType(r.TokenType))
{
objs.Add(GetObjectArrayType(serializer, r));
}
}
value.SetValue(target, ConvertValueToType(property, objs.ToArray()));
}
}
else
{
var val = serializer.Deserialize(r);
value.SetValue(target, ConvertValueToType(property, val));
}
}
return(target);
}
