protected override void WriteObjectProperties(JsonWriter writer, Expression instance, IReadOnlyCollection <Property> properties, JsonSerializer serializer)
{
if (instance is ConstantExpression constantExpression)
{
writer.CheckNotNull(nameof(writer)).WritePropertyName(nameof(ConstantExpression.Type));
serializer.CheckNotNull(nameof(serializer)).Serialize(writer, constantExpression.Type);
var type = constantExpression.Type?.ToType();
if (constantExpression.Value is not null)
{
var valueType = constantExpression.Value.GetType();
if (valueType != type)
{
type = valueType;
writer.WritePropertyName(ValueTypePropertyName);
serializer.Serialize(writer, type.AsTypeInfo());
}
}
writer.WritePropertyName(nameof(ConstantExpression.Value));
serializer.Serialize(writer, constantExpression.Value, type);
}
else
{
base.WriteObjectProperties(writer, instance, properties, serializer);
}
}
protected override void WriteObjectProperties(JsonWriter writer, VariableQueryArgumentList instance, IReadOnlyCollection <Property> properties, JsonSerializer serializer)
{
writer.CheckNotNull(nameof(writer)).WritePropertyName(nameof(VariableQueryArgumentList.ElementType));
serializer.CheckNotNull(nameof(serializer)).Serialize(writer, instance.CheckNotNull(nameof(instance)).ElementType);
writer.WritePropertyName(nameof(VariableQueryArgumentList.Values));
serializer.Serialize(writer, instance.Values, instance.ElementType?.Type);
}
public virtual T?ReadJson(JsonReader reader, Type objectType, T?existingValue, JsonSerializer serializer)
{
reader.CheckNotNull(nameof(reader));
objectType.CheckNotNull(nameof(objectType));
serializer.CheckNotNull(nameof(serializer));
if (reader.TokenType == JsonToken.Null)
{
return(default);
public override TypeInfo?ReadJson(JsonReader reader, Type objectType, TypeInfo?existingValue, JsonSerializer serializer)
{
reader.CheckNotNull(nameof(reader));
serializer.CheckNotNull(nameof(serializer));
if (reader.TokenType == JsonToken.String &&
reader.Value is string typeKey &&
KnownTypesRegistry.TryGetTypeInfo(typeKey, out var typeInfo))
{
return(typeInfo);
}
return(base.ReadJson(reader, objectType, existingValue, serializer));
}
protected override void ReadObjectProperties(JsonReader reader, DynamicObject result, Dictionary <string, Property> properties, JsonSerializer serializer)
{
reader.CheckNotNull(nameof(reader)).Advance();
result.CheckNotNull(nameof(result));
serializer.CheckNotNull(nameof(serializer));
TypeInfo?typeInfo = null;
void SetResult(IEnumerable <DynamicProperty>?properties = null)
{
reader.AssertEndObject();
result.Type = typeInfo;
if (properties?.Any() is true)
{
result.Properties = new PropertySet(properties);
}
}
if (reader.IsProperty(nameof(DynamicObject.Type)))
{
typeInfo = reader.Read <TypeInfo?>(serializer);
reader.Advance();
}
bool IsProperty(string property, out bool isDynamicValueType)
{
isDynamicValueType = false;
if (reader.IsProperty(property))
{
return(true);
}
if (reader.IsProperty($"Dynamic{property}"))
{
isDynamicValueType = true;
return(true);
}
return(false);
}
if (IsProperty(ValueProperty, out var isDynamicValue))
{
var value = isDynamicValue
? reader.Read <DynamicObject>(serializer)
: reader.Read(typeInfo, serializer);
SetResult(new[] { new DynamicProperty(string.Empty, value) });
return;
}
if (IsProperty(ValuesProperty, out isDynamicValue))
{
reader.Advance();
if (reader.TokenType == JsonToken.Null)
{
SetResult();
return;
}
if (reader.TokenType != JsonToken.StartArray)
{
throw reader.CreateException($"Expected array");
}
var elementType = TypeHelper.GetElementType(typeInfo?.ToType()) ?? typeof(object);
bool TryReadNextItem(out object?value)
{
var itemType = isDynamicValue ? typeof(DynamicObject) : elementType;
if (!reader.TryRead(itemType, serializer, out value))
{
if (reader.TokenType == JsonToken.EndArray)
{
return(false);
}
throw reader.CreateException("Unexpected token structure.");
}
return(true);
}
var values = new List <object?>();
while (TryReadNextItem(out var item))
{
values.Add(item);
}
if (isDynamicValue)
{
elementType = typeof(object);
}
else if (values.Any(x => x is not null && (elementType == typeof(object) || !elementType.IsInstanceOfType(x))) &&
values.All(x => x is null || x is string))
{
elementType = typeof(string);
}
var valueArray = values.CastCollectionToArrayOfType(elementType);
SetResult(new[] { new DynamicProperty(string.Empty, valueArray) });
return;
}
if (reader.IsProperty(nameof(DynamicObject.Properties)))
{
reader.Advance();
if (reader.TokenType == JsonToken.Null)
{
SetResult();
return;
}
if (reader.TokenType != JsonToken.StartArray)
{
throw reader.CreateException("Expected array");
}
var propertySet = new List <DynamicProperty>();
bool NextItem()
{
reader.Advance();
return(reader.TokenType != JsonToken.EndArray);
}
while (NextItem())
{
reader.AssertStartObject(false);
reader.AssertProperty(nameof(DynamicProperty.Name));
var name = reader.ReadAsString() ?? throw reader.CreateException("Property name must not be null");
reader.AssertProperty(nameof(Type));
var type = reader.Read <TypeInfo?>(serializer);
reader.AssertProperty(nameof(DynamicProperty.Value));
var value = reader.Read(type, serializer);
reader.AssertEndObject();
propertySet.Add(new DynamicProperty(name, value));
}
SetResult(propertySet);
return;
}
throw reader.CreateException($"Unexpected token {reader.TokenType}");
}
protected override void WriteObjectProperties(JsonWriter writer, DynamicObject instance, IReadOnlyCollection <Property> properties, JsonSerializer serializer)
{
writer.CheckNotNull(nameof(writer));
serializer.CheckNotNull(nameof(serializer));
var instanceType = instance.CheckNotNull(nameof(instance)).Type;
var dynamicProperties = instance.Properties;
if (TryGetWrappedValue(dynamicProperties, out var value))
{
var type = instanceType ?? CreateTypeInfo(value);
writer.WritePropertyName(nameof(DynamicObject.Type));
serializer.Serialize(writer, type);
var propertyName = type.IsCollection() ? ValuesProperty : ValueProperty;
var isDynamicValue =
value is DynamicObject ||
(value is object[] objectArray && objectArray.Any(x => x is DynamicObject));
if (isDynamicValue)
{
propertyName = $"Dynamic{propertyName}";
}
writer.WritePropertyName(propertyName);
serializer.Serialize(writer, value, type?.ToType());
}
else
{
if (instanceType is not null)
{
writer.WritePropertyName(nameof(DynamicObject.Type));
serializer.Serialize(writer, instanceType);
}
if (dynamicProperties?.Any() is true)
{
writer.WritePropertyName(nameof(DynamicObject.Properties));
writer.WriteStartArray();
foreach (var property in dynamicProperties)
{
writer.WriteStartObject();
writer.WritePropertyName(nameof(DynamicProperty.Name));
writer.WriteValue(property.Name);
writer.WritePropertyName(nameof(Type));
serializer.Serialize(writer, CreateTypeInfo(property.Value));
writer.WritePropertyName(nameof(DynamicProperty.Value));
if (property.Value is null)
{
writer.WriteNull();
}
else
{
serializer.Serialize(writer, property.Value);
}
writer.WriteEndObject();
}
writer.WriteEndArray();
}
}
}
public override void WriteJson(JsonWriter writer, object?value, JsonSerializer serializer)
{
serializer.CheckNotNull(nameof(serializer));
serializer.Serialize(writer, value);
}
