public JsonSerializerOptionsState(JsonSerializerOptions options)
{
ObjectMappingRegistry = new ObjectMappingRegistry(options);
ObjectMappingConventionRegistry = new ObjectMappingConventionRegistry();
DiscriminatorConventionRegistry = new DiscriminatorConventionRegistry(options);
DictionaryKeyConverterRegistry = new DictionaryKeyConverterRegistry(options);
}
static TelescopeConverter()
{
options = new JsonSerializerOptions()
{
WriteIndented = true,
};
options.SetupExtensions();
DiscriminatorConventionRegistry registry = options.GetDiscriminatorConventionRegistry();
registry.ClearConventions();
registry.DiscriminatorPolicy = DiscriminatorPolicy.Always;
// Cell types
registry.RegisterConvention(new DefaultDiscriminatorConvention <string>(options, "cell_type"));
registry.RegisterType <CodeCell>();
registry.RegisterType <MarkdownCell>();
registry.RegisterType <RawCell>();
// Cell output types
registry.RegisterConvention(new DefaultDiscriminatorConvention <string>(options, "output_type"));
registry.RegisterType <DataOutput>();
registry.RegisterType <ErrorOutput>();
registry.RegisterType <ExecuteResultOutput>();
registry.RegisterType <StreamOutput>();
}
public void WritePolymorphicObject(DiscriminatorPolicy discriminatorPolicy, string expected)
{
JsonSerializerOptions options = new JsonSerializerOptions();
options.SetupExtensions();
DiscriminatorConventionRegistry registry = options.GetDiscriminatorConventionRegistry();
registry.ClearConventions();
registry.RegisterConvention(new DefaultDiscriminatorConvention <int>(options));
registry.RegisterType <NameObject>();
registry.DiscriminatorPolicy = discriminatorPolicy;
BaseObjectHolder obj = new BaseObjectHolder
{
BaseObject = new NameObject
{
Id = 1,
Name = "foo"
},
NameObject = new NameObject
{
Id = 2,
Name = "bar"
}
};
string actual = JsonSerializer.Serialize(obj, options);
Assert.Equal(expected, actual);
}
public static void ConfigJsonOptions(JsonSerializerOptions options)
{
options.Converters.Add(new ObjectIdConverter());
options.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
options.SetupExtensions();
DiscriminatorConventionRegistry registry = options.GetDiscriminatorConventionRegistry();
registry.ClearConventions();
registry.RegisterConvention(new DefaultDiscriminatorConvention <string>(options, "_t"));
registry.RegisterType <TextMsg>();
registry.RegisterType <FileMsg>();
registry.RegisterType <ImageMsg>();
registry.RegisterType <RTextMsg>();
registry.RegisterType <RImageMsg>();
registry.RegisterType <RFileMsg>();
registry.RegisterType <RForwardMsg>();
registry.RegisterType <WsSendChatMsg>();
registry.RegisterType <WsSendOnlineStatusMsg>();
registry.RegisterType <WsSendUnreadCountMsg>();
registry.RegisterType <WsSendErrMsg>();
registry.RegisterType <WsRecvChatMsg>();
registry.RegisterType <WsRecvReadPositionMsg>();
registry.DiscriminatorPolicy = DiscriminatorPolicy.Always;
options.IgnoreNullValues = true;
options.AllowTrailingCommas = true;
options.ReadCommentHandling = JsonCommentHandling.Skip;
}
public SerializationRegistry(CborOptions options)
{
ConverterRegistry = new CborConverterRegistry(options);
ObjectMappingRegistry = new ObjectMappingRegistry(this);
ObjectMappingConventionRegistry = new ObjectMappingConventionRegistry();
DiscriminatorConventionRegistry = new DiscriminatorConventionRegistry(this);
}
private static JsonSerializerOptions CreateJsonSerializerOptions()
{
var options = new JsonSerializerOptions
{
MaxDepth = int.MaxValue,
Converters = { new JsonStringEnumConverter() },
IgnoreNullValues = true
};
options.SetupExtensions();
DiscriminatorConventionRegistry registry = options.GetDiscriminatorConventionRegistry();
registry.ClearConventions();
registry.RegisterConvention(new TonClientDiscriminatorConvention(options));
registry.DiscriminatorPolicy = DiscriminatorPolicy.Always;
var nestedTypes = typeof(Abi.Contract).Assembly.GetTypes().Where(t => t.IsNestedPublic);
// register all nested types from models
foreach (Type type in nestedTypes)
{
registry.RegisterType(type);
}
return(options);
}
public void TestWrite()
{
JsonSerializerOptions options = new JsonSerializerOptions().SetupExtensions();
DiscriminatorConventionRegistry registry = options.GetDiscriminatorConventionRegistry();
registry.ClearConventions();
registry.RegisterConvention(new DefaultDiscriminatorConvention <string>(options, "$type"));
registry.RegisterType <MessageResult>();
registry.RegisterType <StatusResult>();
const string json1 = "{\"data\":{\"$type\":\"message\",\"message_id\":770,\"message_content\":1},\"id\":\"6nd28c1\",\"status\":\"ok\"}";
Response response1 = JsonSerializer.Deserialize <Response>(json1, options);
Assert.NotNull(response1);
Assert.Equal("6nd28c1", response1.Id);
Assert.Equal("ok", response1.Status);
Assert.NotNull(response1.Data);
MessageResult messageResult = Assert.IsType <MessageResult>(response1.Data);
Assert.Equal(770, messageResult.MessageId);
Assert.Equal(1, messageResult.Content);
const string json2 = "{\"data\":{\"$type\":\"status\",\"status_id\":12},\"id\":\"6nd28c1\",\"status\":\"ok\"}";
Response response2 = JsonSerializer.Deserialize <Response>(json2, options);
Assert.NotNull(response2);
Assert.Equal("6nd28c1", response2.Id);
Assert.Equal("ok", response2.Status);
Assert.NotNull(response2.Data);
StatusResult statusResult = Assert.IsType <StatusResult>(response2.Data);
Assert.Equal(12, statusResult.StatusId);
}
public void ReadWithNoDiscriminator()
{
JsonSerializerOptions options = new JsonSerializerOptions();
options.SetupExtensions();
DiscriminatorConventionRegistry registry = options.GetDiscriminatorConventionRegistry();
registry.ClearConventions();
const string json = @"{""Name"":""foo"",""Id"":12}";
BaseObject obj = JsonSerializer.Deserialize <BaseObject>(json, options);
Assert.NotNull(obj);
Assert.Equal(12, obj.Id);
}
public void ReadPolymorphicObjectWithDefaultDiscriminatorConvention()
{
const string hexBuffer = "A2625F7478374461686F6D65792E43626F722E54657374732E426173654F626A656374486F6C6465722C204461686F6D65792E43626F722E54657374736A426173654F626A656374A3625F746A4E616D654F626A656374644E616D6563666F6F62496401";
CborOptions options = new CborOptions();
DiscriminatorConventionRegistry registry = options.Registry.DiscriminatorConventionRegistry;
registry.RegisterConvention(new AttributeBasedDiscriminatorConvention <string>(options.Registry));
registry.RegisterType <NameObject>();
object obj = Helper.Read <object>(hexBuffer, options);
Assert.NotNull(obj);
Assert.IsType <BaseObjectHolder>(obj);
}
public void ReadNonAssignablePolymorphicObject()
{
const string json = @"{""BaseObject"":{""$type"":13}}";
JsonSerializerOptions options = new JsonSerializerOptions();
options.SetupExtensions();
DiscriminatorConventionRegistry registry = options.GetDiscriminatorConventionRegistry();
registry.ClearConventions();
registry.RegisterConvention(new DefaultDiscriminatorConvention <int>(options));
registry.RegisterType <NameObject>();
registry.RegisterType <OtherObject>();
Assert.ThrowsAny <JsonException>(() => JsonSerializer.Deserialize <BaseObjectHolder>(json, options));
}
public void WriteWithNoDiscriminatorConvention()
{
CborOptions options = new CborOptions();
DiscriminatorConventionRegistry registry = options.Registry.DiscriminatorConventionRegistry;
registry.ClearConventions();
NameObject obj = new NameObject
{
Id = 12,
Name = "foo"
};
const string hexBuffer = "A2644E616D6563666F6F6249640C";
Helper.TestWrite(obj, hexBuffer, null, options);
}
public void ReadPolymorphicObjectWithDefaultDiscriminatorConvention()
{
const string json = @"{""$type"":""Dahomey.Json.Tests.BaseObjectHolder, Dahomey.Json.Tests"",""BaseObject"":{""$type"":12,""Name"":""foo"",""Id"":1}}";
JsonSerializerOptions options = new JsonSerializerOptions();
options.SetupExtensions();
DiscriminatorConventionRegistry registry = options.GetDiscriminatorConventionRegistry();
registry.RegisterConvention(new AttributeBasedDiscriminatorConvention <int>(options));
registry.RegisterType <NameObject>();
object obj = JsonSerializer.Deserialize <object>(json, options);
Assert.NotNull(obj);
Assert.IsType <BaseObjectHolder>(obj);
}
public void Test()
{
JsonSerializerOptions options = new JsonSerializerOptions();
options.SetupExtensions();
DiscriminatorConventionRegistry registry = options.GetDiscriminatorConventionRegistry();
registry.RegisterType <InheritedClass>();
const string json = @"{""$type"":""InheritedClass"",""Id"":12,""Name"":""foo"",""Age"":13}";
BaseClass obj = Helper.Read <BaseClass>(json, options);
Assert.NotNull(obj);
Assert.Equal(12, obj.Id);
Assert.Equal("foo", obj.Name);
Assert.Equal(13, obj.Age);
}
public void ReadWithCustomDiscriminator()
{
JsonSerializerOptions options = new JsonSerializerOptions();
options.SetupExtensions();
DiscriminatorConventionRegistry registry = options.GetDiscriminatorConventionRegistry();
registry.RegisterConvention(new CustomDiscriminatorConvention());
registry.RegisterType(typeof(NameObject2));
const string json = @"{""BaseObject"":{""type"":263970807,""Name"":""foo"",""Id"":1}}";
BaseObjectHolder2 obj = JsonSerializer.Deserialize <BaseObjectHolder2>(json, options);
Assert.NotNull(obj);
Assert.IsType <NameObject2>(obj.BaseObject);
Assert.Equal("foo", ((NameObject2)obj.BaseObject).Name);
Assert.Equal(1, obj.BaseObject.Id);
}
public void ReadPolymorphicObject()
{
const string json = @"{""BaseObject"":{""$type"":12,""Name"":""foo"",""Id"":1}}";
JsonSerializerOptions options = new JsonSerializerOptions();
options.SetupExtensions();
DiscriminatorConventionRegistry registry = options.GetDiscriminatorConventionRegistry();
registry.RegisterConvention(new AttributeBasedDiscriminatorConvention <int>(options));
registry.RegisterType <NameObject>();
BaseObjectHolder obj = JsonSerializer.Deserialize <BaseObjectHolder>(json, options);
Assert.NotNull(obj);
Assert.IsType <NameObject>(obj.BaseObject);
Assert.Equal("foo", ((NameObject)obj.BaseObject).Name);
Assert.Equal(1, obj.BaseObject.Id);
}
public void TestPolymorphicMissingMemberHandlingIgnore()
{
JsonSerializerOptions options = new JsonSerializerOptions().SetupExtensions();
options.SetMissingMemberHandling(MissingMemberHandling.Ignore);
DiscriminatorConventionRegistry registry = options.GetDiscriminatorConventionRegistry();
registry.ClearConventions();
registry.RegisterConvention(new DefaultDiscriminatorConvention <string>(options, "Type"));
registry.RegisterType <Derived>();
const string json = @"{""Type"":""Derived"",""Int"":42,""String"":""xyz"",""Missing"":0}";
var obj = JsonSerializer.Deserialize <Base>(json, options);
Assert.NotNull(obj);
Assert.IsType <Derived>(obj);
Assert.Equal(42, obj.Int);
Assert.Equal("xyz", (obj as Derived).String);
}
public void WriteWithNoDiscriminatorConvention()
{
JsonSerializerOptions options = new JsonSerializerOptions();
options.SetupExtensions();
DiscriminatorConventionRegistry registry = options.GetDiscriminatorConventionRegistry();
registry.ClearConventions();
NameObject obj = new NameObject
{
Id = 12,
Name = "foo"
};
string actual = JsonSerializer.Serialize <BaseObject>(obj, options);
const string expected = @"{""Name"":""foo"",""Id"":12}";
Assert.Equal(expected, actual);
}
public void ReadPolymorphicObjectWithDeferredTypeProperty()
{
const string json = @"{""BaseObject"":{""Name"":""foo"",""Id"":1,""Unknown"":{""Prop1"":12,""Prop2"":""bar""},""$type"":12}}";
JsonSerializerOptions options = new JsonSerializerOptions();
options.SetupExtensions();
DiscriminatorConventionRegistry registry = options.GetDiscriminatorConventionRegistry();
registry.ClearConventions();
registry.RegisterConvention(new DefaultDiscriminatorConvention <int>(options));
registry.RegisterType <NameObject>();
BaseObjectHolder obj = JsonSerializer.Deserialize <BaseObjectHolder>(json, options);
Assert.NotNull(obj);
NameObject nameObject = Assert.IsType <NameObject>(obj.BaseObject);
Assert.Equal("foo", nameObject.Name);
Assert.Equal(1, nameObject.Id);
}
public void Test()
{
JsonSerializerOptions options = new JsonSerializerOptions();
options.SetupExtensions();
DiscriminatorConventionRegistry registry = options.GetDiscriminatorConventionRegistry();
registry.ClearConventions();
registry.RegisterConvention(new DefaultDiscriminatorConvention <string>(options, "Tag"));
registry.RegisterType <Box>();
registry.RegisterType <Circle>();
Shape origin1 = new Box {
Width = 10, Height = 20
};
Shape origin2 = new Circle {
Radius = 30
};
string json1 = JsonSerializer.Serialize(origin1, options);
string json2 = JsonSerializer.Serialize(origin2, options);
Assert.Equal(@"{""Tag"":""Box"",""Width"":10,""Height"":20}", json1);
Assert.Equal(@"{""Tag"":""Circle"",""Radius"":30}", json2);
Shape restored1 = JsonSerializer.Deserialize <Shape>(json1, options);
Shape restored2 = JsonSerializer.Deserialize <Shape>(json2, options);
Assert.NotNull(restored1);
Box restoredBox = Assert.IsType <Box>(restored1);
Assert.Equal(10, restoredBox.Width);
Assert.Equal(20, restoredBox.Height);
Assert.NotNull(restored2);
Circle restoredCircle = Assert.IsType <Circle>(restored2);
Assert.Equal(30, restoredCircle.Radius);
}
public void WriteWithCustomDiscriminator()
{
JsonSerializerOptions options = new JsonSerializerOptions();
options.SetupExtensions();
DiscriminatorConventionRegistry registry = options.GetDiscriminatorConventionRegistry();
registry.RegisterConvention(new CustomDiscriminatorConvention());
registry.RegisterType(typeof(NameObject2));
BaseObjectHolder2 obj = new BaseObjectHolder2
{
BaseObject = new NameObject2
{
Id = 1,
Name = "foo"
},
};
string actual = JsonSerializer.Serialize(obj, options);
const string expected = @"{""BaseObject"":{""type"":263970807,""Name"":""foo"",""Id"":1},""NameObject"":null}";
Assert.Equal(expected, actual);
}
public DiscriminatorMapping(DiscriminatorConventionRegistry discriminatorConventionRegistry,
IObjectMapping objectMapping)
{
_discriminatorConventionRegistry = discriminatorConventionRegistry;
_objectMapping = objectMapping;
}
