public void EnumDiscriminatorPropertySupportNamingStrategy()
        {
            var serializerSettings = new JsonSerializerSettings
            {
                ContractResolver = new DefaultContractResolver
                {
                    NamingStrategy = new SnakeCaseNamingStrategy(),
                },
                Converters = new List <JsonConverter>
                {
                    new StringEnumConverter
                    {
                        NamingStrategy = new SnakeCaseNamingStrategy()
                    },
                    JsonSubtypesConverterBuilder
                    .Of(typeof(IMyType), "enum_value")
                    .RegisterSubtype(typeof(MyTypeOne), EnumType.EnumMemberOne)
                    .RegisterSubtype(typeof(MyTypeTwo), EnumType.EnumMemberTwo)
                    .Build()
                }
            };

            var json   = "{\"enum_value\":\"enum_member_one\"}";
            var result = JsonConvert.DeserializeObject <IMyType>(json, serializerSettings);

            var serializeObject = JsonConvert.SerializeObject(result, serializerSettings);

            Assert.AreEqual(json, serializeObject);
        }
Example #2
0
        public void CheckDeserializeFirst()
        {
            var settings = new JsonSerializerSettings();

            JsonConvert.DefaultSettings = () => settings;

            settings.Converters.Add(JsonSubtypesConverterBuilder
                                    .Of(typeof(SimpleBase), "type")
                                    .SerializeDiscriminatorProperty(true)
                                    .RegisterSubtype(typeof(SimpleChildA), "TypeA")
                                    .RegisterSubtype(typeof(SimpleChildB), "TypeB")
                                    .Build());


            SimpleBase test_object = new SimpleChildB()
            {
                Name = "bob", Height = 36
            };

            var json_first = "{\"type\":\"TypeB\",\"Height\":36,\"Name\":\"bob\"}";

            var result = JsonConvert.DeserializeObject <SimpleBase>(json_first);

            Assert.IsInstanceOf(typeof(SimpleChildB), result);
        }
Example #3
0
        public void CheckExplicitLast()
        {
            var settings = new JsonSerializerSettings();

            JsonConvert.DefaultSettings = () => settings;

            settings.Converters.Add(JsonSubtypesConverterBuilder
                                    .Of(typeof(SimpleBase), "type")
                                    .SerializeDiscriminatorProperty(false)
                                    .RegisterSubtype(typeof(SimpleChildA), "TypeA")
                                    .RegisterSubtype(typeof(SimpleChildB), "TypeB")
                                    .Build());


            SimpleBase test_object = new SimpleChildA()
            {
                Name = "bob", Age = 12
            };


            var json_first = "{\"Age\":12,\"Name\":\"bob\",\"type\":\"TypeA\"}";

            var result = JsonConvert.SerializeObject(test_object);

            Assert.AreEqual(json_first, result);
        }
Example #4
0
        public static JsonSerializerSettings AddValidatorConverter(this JsonSerializerSettings settings)
        {
            settings.Converters.Add(JsonSubtypesConverterBuilder
                                    .Of(typeof(Specification <ICheckElementViewModel>), "Type") // type property is only defined here
                                    .RegisterSubtype(typeof(CheckElement_IsChecked_Validator),
                                                     nameof(CheckElement_IsChecked_Validator))
                                    .RegisterSubtype(typeof(CheckElement_IsNotChecked_Validator),
                                                     nameof(CheckElement_IsNotChecked_Validator))
                                    .SerializeDiscriminatorProperty() // ask to serialize the type property
                                    .Build());

            settings.Converters.Add(JsonSubtypesConverterBuilder
                                    .Of(typeof(Specification <ISelectElementViewModel>), "Type") // type property is only defined here
                                    .RegisterSubtype(typeof(SelectElement_SelectionMade_Validator),
                                                     nameof(SelectElement_SelectionMade_Validator))
                                    .SerializeDiscriminatorProperty() // ask to serialize the type property
                                    .Build());

            settings.Converters.Add(JsonSubtypesConverterBuilder
                                    .Of(typeof(Specification <ITextElementViewModel>), "Type") // type property is only defined here
                                    .RegisterSubtype(typeof(TextElement_MaximumLength_Validator),
                                                     nameof(TextElement_MaximumLength_Validator))
                                    .RegisterSubtype(typeof(TextElement_MinimunLength_Validator),
                                                     nameof(TextElement_MinimunLength_Validator))
                                    .SerializeDiscriminatorProperty() // ask to serialize the type property
                                    .Build());

            return(settings);
        }
        public void UpdateSerializables()
        {
            original.Objects = new List <MeepleObjectSerializable>();
            AddSerializable(root);
            var settings = new JsonSerializerSettings();

            settings.ContractResolver = new CamelCasePropertyNamesContractResolver();

            settings.Converters.Add(JsonSubtypesConverterBuilder
                                    .Of(typeof(MeepleObjectSerializable), "type") // type property is only defined here
                                    .RegisterSubtype(typeof(CardSerializable), "card")
                                    .RegisterSubtype(typeof(GridSerializable), "grid")
                                    .RegisterSubtype(typeof(BoardSerializable), "board")
                                    .RegisterSubtype(typeof(TextureImporterSerializable), "cardImporter")
                                    .RegisterSubtype(typeof(ObjImporterSerializable), "objImporter")
                                    .RegisterSubtype(typeof(DeckSerializable), "deck")
                                    .RegisterSubtype(typeof(MeepleButtonSerializable), "meepleButton")
                                    .RegisterSubtype(typeof(CustomObjectSerializable), "customObject")
                                    .RegisterSubtype(typeof(HandSerializable), "hand")
                                    .SerializeDiscriminatorProperty() // ask to serialize the type property
                                    .Build());

            var export = JsonConvert.SerializeObject(original, settings);

            Debug.Log(export);
            File.WriteAllText($@"{path}", export);
        }
Example #6
0
        public void NestedTypeDeserializeTest()
        {
            var settings = new JsonSerializerSettings();

            JsonConvert.DefaultSettings = () => settings;

            settings.Converters.Add(JsonSubtypesConverterBuilder
                                    .Of(typeof(Animal), "type")
                                    .RegisterSubtype(typeof(Cat), AnimalType.Cat)
                                    .RegisterSubtype(typeof(Dog), AnimalType.Dog)
                                    // Shark is not registered
                                    .RegisterSubtype(typeof(HammerheadShark), AnimalType.HammerheadShark)
                                    .Build());

            var json = "{\"age\":11,\"fins\":3,\"teethRows\":4,\"hammerSize\":42.1,\"type\":4}";

            var result = JsonConvert.DeserializeObject <Animal>(json);


            Assert.AreEqual(typeof(HammerheadShark), result.GetType());
            Assert.AreEqual(11, result.Age);
            Assert.AreEqual(3u, (result as Fish)?.FinCount);
            Assert.AreEqual(4u, (result as Shark)?.TeethRows);
            Assert.AreEqual(42.1f, (result as HammerheadShark)?.HammerSize);
        }
Example #7
0
        public void UnregisteredTypeSerializeTest2()
        {
            var settings = new JsonSerializerSettings();

            JsonConvert.DefaultSettings = () => settings;

            settings.Converters.Add(JsonSubtypesConverterBuilder
                                    .Of(typeof(Animal), "type")
                                    .RegisterSubtype(typeof(Cat), AnimalType.Cat)
                                    .RegisterSubtype(typeof(Dog), AnimalType.Dog)
                                    // Shark is not registered
                                    .RegisterSubtype(typeof(HammerheadShark), AnimalType.HammerheadShark)
                                    .Build());

            var json = "{\"age\":11,\"fins\":4,\"teethRows\":4}"; // no type property shall be added

            var result = JsonConvert.SerializeObject(new Shark
            {
                Age       = 11,
                FinCount  = 4,
                TeethRows = 4
            });

            Assert.AreEqual(json, result);
        }
Example #8
0
        public static void AddYandexKassa(this IServiceCollection services, Action <Configuration> configure)
        {
            var cfg = new Configuration();

            configure(cfg);

            services.AddSingleton(cfg);
            services.AddSingleton <IPaymentService, PaymentService>();

            var settings = new JsonSerializerSettings();

            JsonConvert.DefaultSettings = () => settings;

            settings.Converters.Add(JsonSubtypesConverterBuilder
                                    .Of(typeof(PaymentMethod), "Id")
                                    .SerializeDiscriminatorProperty()
                                    .RegisterSubtype(typeof(BankCardPaymentMethod), PaymentMethodType.BankCard)
                                    .RegisterSubtype(typeof(ApplePayPaymentMethod), PaymentMethodType.ApplePay)
                                    .RegisterSubtype(typeof(GooglePayPaymentMethod), PaymentMethodType.GooglePay)
                                    .RegisterSubtype(typeof(YandexMoneyPaymentMethod), PaymentMethodType.YandexMoney)
                                    .RegisterSubtype(typeof(QiwiPaymentMethod), PaymentMethodType.Qiwi)
                                    .RegisterSubtype(typeof(WebmoneyPaymentMethod), PaymentMethodType.Webmoney)
                                    .RegisterSubtype(typeof(WeChatPaymentMethod), PaymentMethodType.WeChat)
                                    .RegisterSubtype(typeof(SberbankPaymentMethod), PaymentMethodType.Sberbank)
                                    .RegisterSubtype(typeof(AlfabankPaymentMethod), PaymentMethodType.Alfabank)
                                    .RegisterSubtype(typeof(TinkoffbankPaymentMethod), PaymentMethodType.Tinkoffbank)
                                    .RegisterSubtype(typeof(B2BSberbankPaymentMethod), PaymentMethodType.B2BSberbank)
                                    .RegisterSubtype(typeof(MobileBalancePaymentMethod), PaymentMethodType.MobileBalance)
                                    .RegisterSubtype(typeof(CashPaymentMethod), PaymentMethodType.Cash)
                                    .RegisterSubtype(typeof(InstallmentsPaymentMethod), PaymentMethodType.Installments)
                                    .Build());
        }
        public void TestIfNestedObjectIsSerialized2()
        {
            var settings = new JsonSerializerSettings();

            JsonConvert.DefaultSettings = () => settings;

            settings.Converters.Add(JsonSubtypesConverterBuilder
                                    .Of(typeof(IExpression2), "Type")
                                    .SerializeDiscriminatorProperty()
                                    .RegisterSubtype(typeof(ConstantExpression2), "Constant")
                                    .RegisterSubtype(typeof(BinaryExpression2), "Binary")
                                    .Build());

            var target = JsonConvert.SerializeObject(new BinaryExpression2
            {
                SubExpressionA = new ConstantExpression2 {
                    Value = "A"
                },
                SubExpressionB = new ConstantExpression2 {
                    Value = "B"
                }
            });

            Assert.AreEqual("{" +
                            "\"SubExpressionA\":{\"Value\":\"A\",\"Type\":\"Constant\"}," +
                            "\"SubExpressionB\":{\"Value\":\"B\",\"Type\":\"Constant\"}" +
                            ",\"Type\":\"Binary\"}", target);
        }
        public void ConfigureServices(IServiceCollection services)
        {
            services
            .AddControllers()
            .AddNewtonsoftJson(options =>
            {
                options.SerializerSettings.Converters.Add(
                    JsonSubtypesConverterBuilder
                    .Of(typeof(Musician), nameof(Musician.InstrumentType))
                    .RegisterSubtype(typeof(Musician.Guitarist), "Guitar")
                    .RegisterSubtype(typeof(Musician.Pianist), "Piano")
                    .SerializeDiscriminatorProperty()
                    .Build()
                    );
            });

            services.AddMvc();

            services.AddSwaggerGen(c =>
            {
                c.SwaggerDoc("v1", new OpenApiInfo {
                    Title = "My API", Version = "v1"
                });
                c.GeneratePolymorphicSchemas(discriminatorSelector: d => {
                    if (d == typeof(Musician))
                    {
                        return("instrumentType");
                    }
                    return(null);
                });
            });
            services.AddSwaggerGenNewtonsoftSupport();
        }
Example #11
0
        private void Awake()
        {
            _serializerSettings = new JsonSerializerSettings();
            _serializerSettings.Converters.Add(JsonSubtypesConverterBuilder
                                               .Of(typeof(MeepleObjectSerializable), "type") // type property is only defined here
                                               .RegisterSubtype(typeof(CardSerializable), "card")
                                               .RegisterSubtype(typeof(GridSerializable), "grid")
                                               .RegisterSubtype(typeof(BoardSerializable), "board")
                                               .RegisterSubtype(typeof(TextureImporterSerializable), "cardImporter")
                                               .RegisterSubtype(typeof(ObjImporterSerializable), "objImporter")
                                               .RegisterSubtype(typeof(DeckSerializable), "deck")
                                               .RegisterSubtype(typeof(MeepleButtonSerializable), "meepleButton")
                                               .RegisterSubtype(typeof(CustomObjectSerializable), "customObject")
                                               .RegisterSubtype(typeof(HandSerializable), "hand")
                                               .SerializeDiscriminatorProperty() // ask to serialize the type property
                                               .Build());
            _serializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver();

            prefabs.Add(typeof(CardSerializable).ToString(), cardPrefab);
            prefabs.Add(typeof(GridSerializable).ToString(), gridPrefab);
            prefabs.Add(typeof(BoardSerializable).ToString(), boardPrefab);
            prefabs.Add(typeof(DeckSerializable).ToString(), deckPrefab);
            prefabs.Add(typeof(TextureImporterSerializable).ToString(), textureImporterPrefab);
            prefabs.Add(typeof(ObjImporterSerializable).ToString(), objImporterPrefab);
            prefabs.Add(typeof(MeepleButtonSerializable).ToString(), buttonPrefab);
            prefabs.Add(typeof(CustomObjectSerializable).ToString(), customObjectPrefab);
            prefabs.Add(typeof(HandSerializable).ToString(), handPrefab);
        }
Example #12
0
        public void Prueba()
        {
            var settings = new JsonSerializerSettings();

            settings.Converters.Add(JsonSubtypesConverterBuilder
                                    .Of <Map>("Type")
                                    .RegisterSubtype <Door>(1)
                                    .SerializeDiscriminatorProperty()
                                    .Build());
            //using (StreamWriter file = File.CreateText("prueba.json"))
            //{
            //    JsonSerializer serializer = new JsonSerializer();
            //    serializer.Serialize(file, X);
            //}

            var json = JsonConvert.SerializeObject(X, settings);

            var result = JsonConvert.DeserializeObject <Map>(json, settings);

            //List<MapElement> elements = new List<MapElement>();
            //using (StreamReader file = File.OpenText("prueba.json"))
            //{
            //    var animal = JsonConvert.DeserializeObject<MapElement>(file.ReadToEnd());
            //    using (JsonTextReader reader = new JsonTextReader(file))
            //    {
            //        JsonSerializer serializer = new JsonSerializer();
            //        elements = serializer.Deserialize<List<MapElement>>(reader);
            //    }
            //}
        }
Example #13
0
        public void ShouldDeserializeNestedLevel()
        {
            var settings = new JsonSerializerSettings();

            JsonConvert.DefaultSettings = () => settings;

            settings.Converters.Add(JsonSubtypesConverterBuilder
                                    .Of(typeof(Payload), Payload.PAYLOAD_KIND)
                                    .SerializeDiscriminatorProperty()
                                    .RegisterSubtype(typeof(Game), PayloadDiscriminator.GAME)
                                    .RegisterSubtype(typeof(Com), PayloadDiscriminator.COM)
                                    .Build());

            settings.Converters.Add(JsonSubtypesConverterBuilder
                                    .Of(typeof(Game), Game.GAME_KIND)
                                    .SerializeDiscriminatorProperty()
                                    .RegisterSubtype(typeof(Walk), GameDiscriminator.WALK)
                                    .RegisterSubtype(typeof(Run), GameDiscriminator.RUN)
                                    .Build());

            Payload run  = new Run();
            var     data = JsonConvert.SerializeObject(run, settings);

            Assert.IsInstanceOf <Run>(JsonConvert.DeserializeObject <Payload>(data, settings));
        }
Example #14
0
        public void ItRefuseToRegisterTwiceWithTheSameNullValue()
        {
            var jsonSubtypesConverterBuilder = JsonSubtypesConverterBuilder
                                               .Of(typeof(Animal), "type")
                                               .RegisterSubtype(typeof(Cat), null);

            Assert.Throws <ArgumentException>(() => jsonSubtypesConverterBuilder.RegisterSubtype(typeof(Dog), null));
        }
        public void TestNestedObjectInBothWayParallel()
        {
            var settings = new JsonSerializerSettings();

            JsonConvert.DefaultSettings = () => settings;

            settings.Converters.Add(JsonSubtypesConverterBuilder
                                    .Of(typeof(IExpression2), "Type")
                                    .SerializeDiscriminatorProperty()
                                    .RegisterSubtype(typeof(ConstantExpression2), "Constant")
                                    .RegisterSubtype(typeof(BinaryExpression2), "Binary")
                                    .RegisterSubtype(typeof(ManyOrExpression2), "ManyOr")
                                    .Build());


            Action test = () => {
                var target = JsonConvert.SerializeObject(new BinaryExpression2
                {
                    SubExpressionA = new ManyOrExpression2 {
                        OrExpr = new List <IExpression2> {
                            new ConstantExpression2 {
                                Value = "A"
                            }, new ConstantExpression2 {
                                Value = "B"
                            }
                        }
                    },
                    SubExpressionB = new ManyOrExpression2 {
                        OrExpr = new List <IExpression2> {
                            new ConstantExpression2 {
                                Value = "A"
                            }, new ManyOrExpression2 {
                                OrExpr = new List <IExpression2> {
                                    new ConstantExpression2 {
                                        Value = "A"
                                    }, new ConstantExpression2 {
                                        Value = "B"
                                    }
                                }
                            }
                        }
                    }
                });

                var json = "{" +
                           "\"SubExpressionA\":{\"OrExpr\":[{\"Value\":\"A\",\"Type\":\"Constant\"},{\"Value\":\"B\",\"Type\":\"Constant\"}],\"Type\":\"ManyOr\"}," +
                           "\"SubExpressionB\":{\"OrExpr\":[{\"Value\":\"A\",\"Type\":\"Constant\"},{\"OrExpr\":[{\"Value\":\"A\",\"Type\":\"Constant\"},{\"Value\":\"B\",\"Type\":\"Constant\"}],\"Type\":\"ManyOr\"}],\"Type\":\"ManyOr\"}" +
                           ",\"Type\":\"Binary\"}";
                Assert.AreEqual(json, target);


                Assert.AreEqual(json, JsonConvert.SerializeObject(JsonConvert.DeserializeObject <IExpression2>(json)));
            };

            Parallel.For(0, 100, index => test());
        }
        public static IHostBuilder UseCommandHost(this IHostBuilder hostBuilder, string commandFile, string section, Assembly commandAssembly = null, JsonSerializerSettings serializerSettings = null)
        {
            var settings = serializerSettings ?? new JsonSerializerSettings();

            if (commandAssembly != null)
            {
                var converterBuilder = JsonSubtypesConverterBuilder.Of(typeof(ICommand), "kind");

                var commandTypes = commandAssembly.GetTypes().Where(s => s.IsAssignableTo <ICommand>());

                foreach (var command in commandTypes)
                {
                    converterBuilder.RegisterSubtype(command, command.Name);
                }

                settings.Converters.Add(converterBuilder.SerializeDiscriminatorProperty().Build());
            }

            hostBuilder.UseServiceProviderFactory(new AutofacServiceProviderFactory());

            s_commands = JObject.Parse(File.ReadAllText(commandFile)).GetCommandsFromConfiguration(section, settings).GetEnumerator();

            hostBuilder.ConfigureServices((hostContext, services) => services.AddHostedService(p => p.GetService <ICommandProcessor>()));

            hostBuilder.ConfigureContainer <ContainerBuilder>((y, b) =>
            {
                var commandList = new CommandList();

                while (s_commands.MoveNext())
                {
                    var command = s_commands.Current;

                    if (command == null)
                    {
                        return;
                    }

                    commandList.Add(command);

                    b.Register(c => Convert.ChangeType(commandList.Current, command.GetType())).As(command.GetType());
                }

                b.RegisterBuildCallback(x => AutoFacContainerProvider.Container = x);

                b.Register(s => commandList).SingleInstance();

                b.RegisterType <CommandProcessor>().As <ICommandProcessor>().SingleInstance();

                if (commandAssembly != null)
                {
                    b.RegisterAssemblyTypes(commandAssembly).Where(x => x.Name.EndsWith("Handler")).Named(s => s.Name.Split("Handler").First(), typeof(ICommandHandler));
                }
            });

            return(hostBuilder);
        }
Example #17
0
        public static JsonSerializerSettings CreateSettings()
        {
            var stg = new JsonSerializerSettings();

            stg.Converters.Add(JsonSubtypesConverterBuilder
                               .Of(typeof(Descriptor), "Type") // type property is only defined here
                               .RegisterSubtype <ItemDescriptor>("Item")
                               .RegisterSubtype <EquipmentDescriptor>("Equipment")
                               .SerializeDiscriminatorProperty() // ask to serialize the type property
                               .Build());
            return(stg);
        }
Example #18
0
        public static JsonSerializerSettings CreateSettings()
        {
            var stg = new JsonSerializerSettings();

            stg.Converters.Add(JsonSubtypesConverterBuilder
                               .Of(typeof(BaseShip), "Type")     // type property is only defined here
                               .RegisterSubtype <Cruiser>("Cruiser")
                               .SerializeDiscriminatorProperty() // ask to serialize the type property
                               .Build());

            return(stg);
        }
Example #19
0
        public HangfireFixture()
        {
            var settings = new JsonSerializerSettings();

            settings.ContractResolver = new CamelCasePropertyNamesContractResolver();
            settings.Converters.Add(new StringEnumConverter(new CamelCaseNamingStrategy()));
            settings.Converters.Add(JsonSubtypesConverterBuilder
                                    .Of(typeof(CrawlRequestBase), "type")
                                    .RegisterSubtype(typeof(HyperlinkCrawlRequest), CrawlRequestType.Hyperlink)
                                    .SerializeDiscriminatorProperty()
                                    .Build());

            JobHelper.SetSerializerSettings(settings);
        }
 public static JsonConverter JsonConvertor()
 {
     return(JsonSubtypesConverterBuilder.Of(typeof(TransactionResponseValue), "type")
            .RegisterSubtype(typeof(DownloadProgress), nameof(DownloadProgress))
            .RegisterSubtype(typeof(DownloadComplete), nameof(DownloadComplete))
            .RegisterSubtype(typeof(InstallStarted), nameof(InstallStarted))
            .RegisterSubtype(typeof(UninstallStarted), nameof(UninstallStarted))
            .RegisterSubtype(typeof(TransactionProgress), nameof(TransactionProgress))
            .RegisterSubtype(typeof(TransactionError), nameof(TransactionError))
            .RegisterSubtype(typeof(TransactionStarted), nameof(TransactionStarted))
            .RegisterSubtype(typeof(TransactionComplete), nameof(TransactionComplete))
            .RegisterSubtype(typeof(TransactionQueued), nameof(TransactionQueued))
            .RegisterSubtype(typeof(VerificationFailed), nameof(VerificationFailed))
            .Build());
 }
Example #21
0
        public void MultipleRegistrationNotAllowedWithSerializeDiscriminatorProperty()
        {
            var settings = new JsonSerializerSettings();

            JsonConvert.DefaultSettings = () => settings;

            var exception = Assert.Throws <InvalidOperationException>(() => JsonSubtypesConverterBuilder
                                                                      .Of(typeof(Animal), "type")
                                                                      .SerializeDiscriminatorProperty()
                                                                      .RegisterSubtype(typeof(Shark), AnimalType.Shark)
                                                                      .RegisterSubtype(typeof(Shark), AnimalType.HammerheadShark)
                                                                      .Build());

            Assert.AreEqual("Multiple discriminators on single type are not supported when discriminator serialization is enabled", exception.Message);
        }
        public TypeHandlerService(Services services)
        {
            _services = services;

            _builder = JsonSubtypesConverterBuilder.Of(typeof(TypeHandlerBase), nameof(TypeHandlerBase.TypeId));

            if (services?.Options?.StandardTypes != null)
            {
                foreach (var typeHandler in services.Options.StandardTypes.Select(x => x.GetType()).Distinct())
                {
                    Register(typeHandler);
                }
            }

            Register(typeof(UnsupportedTypeHandler));
        }
        public TypeHandlerService(Services services, IEnumerable <TypeHandlerBase> typeHandlers)
        {
            _services = services;

            _builder = JsonSubtypesConverterBuilder.Of(typeof(TypeHandlerBase), nameof(TypeHandlerBase.TypeId));

            if (typeHandlers != null)
            {
                foreach (var typeHandler in typeHandlers.Select(x => x.GetType()).Distinct())
                {
                    Register(typeHandler);
                }
            }

            Register(typeof(UnsupportedTypeHandler));
        }
Example #24
0
        private static JsonConverter CreateJsonConverter <T>(Type baseType, string discriminatorProperty,
                                                             Func <string, string> classNameFactory)
        {
            var subTypes = baseType.Assembly.GetTypes().Where(x =>
                                                              x.IsInNamespace(baseType.Namespace !) && !x.IsAbstract && x.IsAssignableTo <T>());

            var builder = JsonSubtypesConverterBuilder.Of <T>(discriminatorProperty);

            foreach (var type in subTypes)
            {
                var key = classNameFactory(type.Name);
                builder.RegisterSubtype(type, key);
            }

            return(builder.SerializeDiscriminatorProperty().Build());
        }
Example #25
0
 static JsonUtils()
 {
     Settings = new JsonSerializerSettings();
     Settings.Converters
     .Add(JsonSubtypesConverterBuilder
          .Of(typeof(Var), "Type") // type property is only defined here
          .RegisterSubtype(typeof(Var <bool>), VarType.Bool)
          .RegisterSubtype(typeof(Var <int>), VarType.Int)
          .RegisterSubtype(typeof(Var <float>), VarType.Float)
          .RegisterSubtype(typeof(Var <long>), VarType.Long)
          .RegisterSubtype(typeof(Var <string>), VarType.String)
          .RegisterSubtype(typeof(Var <Nuid>), VarType.Nuid)
          .RegisterSubtype(typeof(Var <Entity>), VarType.Entity)
          .RegisterSubtype(typeof(Var <NList>), VarType.List)
          .SerializeDiscriminatorProperty() // ask to serialize the type property
          .Build());
 }
Example #26
0
        public void Init()
        {
            settings = new JsonSerializerSettings();
            JsonConvert.DefaultSettings = () => settings;

            settings.Converters.Add(JsonSubtypesConverterBuilder
                                    .Of(typeof(Payload), Payload.PAYLOAD_KIND)
                                    .RegisterSubtype(typeof(Game), PayloadDiscriminator.GAME)
                                    .RegisterSubtype(typeof(Com), PayloadDiscriminator.COM)
                                    .Build());

            settings.Converters.Add(JsonSubtypesConverterBuilder
                                    .Of(typeof(Game), Game.GAME_KIND)
                                    .RegisterSubtype(typeof(Walk), GameDiscriminator.WALK)
                                    .RegisterSubtype(typeof(Run), GameDiscriminator.RUN)
                                    .Build());
        }
Example #27
0
        public void Init()
        {
            settings = new JsonSerializerSettings();
            JsonConvert.DefaultSettings = () => settings;

            settings.Converters.Add(JsonSubtypesConverterBuilder
                                    .Of(typeof(Payload), Payload.PAYLOAD_KIND)
                                    .RegisterSubtype(typeof(Game), PayloadDiscriminator.GAME)
                                    .RegisterSubtype(typeof(Com), PayloadDiscriminator.COM)
                                    .Build());

            settings.Converters.Add(JsonSubtypesWithPropertyConverterBuilder
                                    .Of(typeof(Game))
                                    .RegisterSubtypeWithProperty(typeof(Walk), nameof(Walk.FootCount))
                                    .RegisterSubtypeWithProperty(typeof(Ride), nameof(Ride.WheelCount))
                                    .Build());
        }
Example #28
0
        public static JsonSerializerSettings AddFormSpecificationConverter(this JsonSerializerSettings settings)
        {
            settings.Converters.Add(JsonSubtypesConverterBuilder
                                    .Of(typeof(Specification <FormViewModel>), "Type") // type property is only defined here
                                    .RegisterSubtype(typeof(AndSpecification <FormViewModel>), nameof(AndSpecification <FormViewModel>))
                                    .RegisterSubtype(typeof(OrSpecification <FormViewModel>), nameof(OrSpecification <FormViewModel>))
                                    .RegisterSubtype(typeof(NotSpecification <FormViewModel>), nameof(NotSpecification <FormViewModel>))
                                    .RegisterSubtype(typeof(IdentitySpecification <FormViewModel>),
                                                     nameof(IdentitySpecification <FormViewModel>))
                                    .RegisterSubtype(typeof(NullSpecification <FormViewModel>),
                                                     nameof(NullSpecification <FormViewModel>))
                                    .RegisterSubtype(typeof(ElementPropertyFormSpecification), nameof(ElementPropertyFormSpecification))
                                    .SerializeDiscriminatorProperty() // ask to serialize the type property
                                    .Build());

            return(settings);
        }
Example #29
0
        private static JsonConverter GetSceneConverter()
        {
            var baseType = typeof(AutonomousScene);

            var sceneTypes = baseType.Assembly.GetTypes()
                             .Where(x => x.IsInNamespace(baseType.Namespace !) && x.IsAssignableTo <IScene>());

            var builder = JsonSubtypesConverterBuilder.Of <IScene>("type");

            foreach (var sceneType in sceneTypes)
            {
                var key = sceneType.Name.Replace("Scene", null).ToCamelCase();
                builder.RegisterSubtype(sceneType, key);
            }

            return(builder.SerializeDiscriminatorProperty().Build());
        }
Example #30
0
        public static JsonSerializerSettings AddEventConverter(this JsonSerializerSettings settings)
        {
            settings.Converters.Add(JsonSubtypesConverterBuilder
                                    .Of(typeof(FormElementEvent), "Type") // type property is only defined here
                                    .RegisterSubtype(typeof(ButtonElementEvent), nameof(ButtonElementEvent))
                                    .RegisterSubtype(typeof(ButtonElementClickedEvent), nameof(ButtonElementClickedEvent))
                                    .RegisterSubtype(typeof(CheckElementEvent), nameof(CheckElementEvent))
                                    .RegisterSubtype(typeof(CheckElementChangedEvent), nameof(CheckElementChangedEvent))
                                    .RegisterSubtype(typeof(SelectElementEvent), nameof(SelectElementEvent))
                                    .RegisterSubtype(typeof(SelectElementChangedEvent), nameof(SelectElementChangedEvent))
                                    .RegisterSubtype(typeof(TextElementEvent), nameof(TextElementEvent))
                                    .RegisterSubtype(typeof(TextElementChangedEvent), nameof(TextElementChangedEvent))
                                    .SerializeDiscriminatorProperty() // ask to serialize the type property
                                    .Build());

            return(settings);
        }