manuc66 / jsonsubtypes Goto Github PK

public class Parent{
    Child childField{get;set;}
}

[JsonConverter(typeof(JsonSubTypes),CHILDTYPE)]
[JsonSubTypes.KnownSubTypes(typeof(Child1),CTYPE.Child1)]
[JsonSubTypes.KnownSubTypes(typeof(Child2),CTYPE.Child2)]
public abstract class Child{

    public enum Discriminator{
        Child1=0,
        Child2=1
    }

    private const string CHILDTYPE="childType"
    [JsonProperty(CHILDTYPE)]
    public abstract  Discriminator Kind{get;}
    
}
public class Child1:Child{
    public int Value{get;set;}
    public override Kind=>Discriminator.Child1;
}
public class Child2:Child{
    public bool Value{get;set;}
    public override Kind=>Discriminator.Child2;
}

    public class Quote
    {
        [JsonProperty("id"), JsonRequired]
        public int Id { get; set; }

        [JsonProperty("type"), JsonRequired]
        public string Type { get; set; }

        [JsonProperty("status"), JsonRequired]
        public long Status { get; set; }

        [JsonProperty("insurer"), JsonRequired]
        public Insurer Insurer { get; set; }

        [JsonProperty("price")]
        public string Price { get; set; }

        [JsonProperty("coverage"), JsonRequired]
        public CoverageBase Coverage { get; set; }
    }

    // Bonus points if I can use this instead of `string Type` in `Quote`.
    public enum CoverageType
    {
        Auto,
        Renter,
    }

    // If this needs to be an empty interface I can do that.
    public abstract class CoverageBase { }

    public class AutoCoverage : CoverageBase
    {
        [JsonProperty("bodily_injury_liability_per_person"), JsonRequired]
        public int BodilyInjuryLiabilityPerPerson { get; set; }

        [JsonProperty("bodily_injury_liability_per_accident"), JsonRequired]
        public int BodilyInjuryLiabilityPerAccident { get; set; }

        [JsonProperty("uninsured_motorist_per_person"), JsonRequired]
        public int UninsuredMotoristPerPerson { get; set; }

        [JsonProperty("uninsured_motorist_per_accident"), JsonRequired]
        public int UninsuredMotoristPerAccident { get; set; }

        [JsonProperty("property_damage_liability"), JsonRequired]
        public int PropertyDamageLiability { get; set; }

        [JsonProperty("collision_deductible")]
        public int? CollisionDeductible { get; set; }

        [JsonProperty("comprehensive_deductible")]
        public int? ComprehensiveDeductible { get; set; }

        [JsonProperty("comprehensive_type"), JsonRequired]
        public string ComprehensiveType { get; set; }

        [JsonProperty("medical_payment"), JsonRequired]
        public int MedicalPayment { get; set; }

        [JsonProperty("towing_road_service"), JsonRequired]
        public bool TowingRoadService { get; set; }

        [JsonProperty("rental_reimbursement"), JsonRequired]
        public bool RentalReimbursement { get; set; }

        [JsonProperty("ride_sharing"), JsonRequired]
        public bool RideSharing { get; set; }
    }

    public class RenterCoverage : CoverageBase
    {
        [JsonProperty("coverage_a_dwelling"), JsonRequired]
        public int CoverageADwelling { get; set; }

        [JsonProperty("coverage_b_other_structures"), JsonRequired]
        public int CoverageBOtherStructures { get; set; }

        [JsonProperty("coverage_c_personal_property"), JsonRequired]
        public int CoverageCPersonalProperty { get; set; }

        [JsonProperty("coverage_loss_of_use_type"), JsonRequired]
        public string CoverageLossOfUseType { get; set; }

        [JsonProperty("coverage_d_loss_of_use"), JsonRequired]
        public int CoverageDLossOfUse { get; set; }

        [JsonProperty("coverage_e_liability"), JsonRequired]
        public int CoverageELiability { get; set; }

        [JsonProperty("coverage_f_medical_per_person"), JsonRequired]
        public int CoverageFMedicalPerPerson { get; set; }

        [JsonProperty("coverage_f_medical_per_accident"), JsonRequired]
        public int CoverageFMedicalPerAccident { get; set; }

        [JsonProperty("deductible"), JsonRequired]
        public int Deductible { get; set; }

        [JsonProperty("extended_replacement_cost_dwelling"), JsonRequired]
        public int ExtendedReplacementCostDwelling { get; set; }
}

// Put the types you are serializing or deserializing here

// Your calls to here
`I have tried putting a parameterless constructor in the base class  to no avail.And i have also tried putting parameterless ctors in the derived classes.I still get the same error.

public abstract class BaseType{
        protected dynamic internalvalue;
    }

public class IscBool: BaseType {

        public bool Value {
            get { return (bool)internalvalue; }
            set { internalvalue = (bool)value; }
        }

        public IscBool(bool val) {
            Value = val;
        }
    }

public class IscNumber : BaseType{

        public double Value {
            get { return (double)internalvalue; }
            set { internalvalue = (double)value; }
        }

        public IscNumber(double val) {
            Value = val;
        }
    }

public class IscString: BaseType {

        public string Value {
            get { return (string)internalvalue; }
            set { internalvalue = (string)value; }
        }

        public IscString(string val) {
            Value = val;
        }
    }

var jsonsettings = new JsonSerializerSettings();
jsonsettings.Converters.Add(JsonSubtypesConverterBuilder
    .Of(typeof(BaseType), "$type")
    .RegisterSubtype(typeof(IscString), TypeDiscriminator.IscString)
    .RegisterSubtype(typeof(IscNumber), TypeDiscriminator.IscNumber)
    .RegisterSubtype(typeof(IscBool), TypeDiscriminator.IscBool)
    .Build());

IscNumber testnumber = new IscNumber(12);
var jsontest = JsonConvert.SerializeObject(testnumber, jsonsettings);

    [DataContract]
    [JsonConverter(typeof(JsonSubtypes), "shapeType")]
    [JsonSubtypes.KnownSubType(typeof(Shape2DReactangle), "Shape2DReactangle")]
    [JsonSubtypes.KnownSubType(typeof(Shape2DPolygon), "Shape2DPolygon")]
    public partial class Shape :  IEquatable<Shape>, IValidatableObject
    {...

    [DataContract]
    public partial class Shape2DPolygon : Shape,  IEquatable<Shape2DPolygon>, IValidatableObject
    {...

    [DataContract]
    public partial class Shape2DReactangle : Shape,  IEquatable<Shape2DReactangle>, IValidatableObject
    {

var stg = new JsonSerializerSettings();
stg.Converters.Add(JsonSubTypes.JsonSubtypesConverterBuilder
                            .Of(typeof(Org.OpenAPITools.Model.Shape), "shapeType")
                            .RegisterSubtype(typeof(Shape2DReactangle), "Shape2DReactangle")
                            .RegisterSubtype(typeof(Shape2DPolygon), "Shape2DPolygon")
                            .SerializeDiscriminatorProperty() // ask to serialize the type property
                            .Build());
var serial = JsonConvert.SerializeObject(position, stg);

[JsonConverter(typeof(JsonSubtypes), nameof(In))]
[JsonSubtypes.KnownSubType(typeof(ChildRequest), "a")]
[JsonSubtypes.KnownSubType(typeof(ChildRequest2), "b")]
public abstract class BaseClass {
    [JsonProperty("in")]
    public In[] In{ get; set; }

    public string Disc => In.First().Disc;
}

    public class Test
    {
        [Fact]
        public void BreakingTest()
        {
            var input = new[] {new Cat(), new Animal()};

            var serializersettings = new JsonSerializerSettings();
            serializersettings.Converters.Add(
                JsonSubtypesConverterBuilder
                    .Of(typeof(Animal), "Type")
                    .SerializeDiscriminatorProperty()
                    .RegisterSubtype(typeof(Cat), typeof(Cat).Name)
                    .Build());

            var result = String.Empty;
            var exception = Record.Exception(() => result = JsonConvert.SerializeObject(input, serializersettings));
            
            Assert.Null(exception);
            Assert.Equal("[{\"Type\":\"Cat\"},{\"Type\":\"Animal\"}]", result);
        }
    }

public class Cat : Animal{}

public class Animal{}

        [JsonConverter(typeof(JsonSubtypes), "ClassName")]
        public class Animal
        {
            public virtual string ClassName { get; }
            public string Color { get; set; }
        }

        public class Faulty
        {
            public static bool ctorCalled = false;
            public Faulty()
            {
                ctorCalled = true;
            }
        }

JsonConvert.DeserializeObject<Animal>(@"{""ClassName"": ""Faulty""}")

[JsonConverter(typeof(JsonSubtypes), "type")]
[JsonSubtypes.KnownSubType(typeof(Dog), AnimalType.Dog)]
[JsonSubtypes.KnownSubType(typeof(Cat), AnimalType.Cat)]
public abstract class Animal
{
    public int Age { get; set; }
}

public class Dog : Animal
{
    public bool CanBark { get; set; } = true;
}

public class Cat : Animal
{
    public int Lives { get; set; } = 7;
}

public enum AnimalType
{
    Dog = 1,
    Cat = 2
}

JsonConvert.DeserializeObject<Animal[]>(json, settings); 
// outputs correct array of [Dog, Cat]

JsonConvert.SerializeObject(new Dog {Age = 3, CanBark = false}, settings);

    [JsonConverter(typeof(JsonSubtypes), "kind")]
    [JsonSubtypes.KnownSubType(typeof(StringFieldEntity), "string")]
    public abstract class FieldEntity : Entity<FieldId>
    {
        public string Name { get; set; }
        
        protected FieldEntity(FieldId id, string name) : base(id)
        {
            Name = name;
        }
    }

    [JsonConverter(typeof(JsonSubtypes))]
    [JsonSubtypes.KnownSubTypeWithProperty(typeof(HeaderWidget), "text")]
    [JsonSubtypes.KnownSubTypeWithProperty(typeof(NameWidget), "placeholder_last_name")]
    public abstract class Widget
    {
        [Newtonsoft.Json.JsonProperty("order", Required = Newtonsoft.Json.Required.Always)]
        public int Order { get; set; }

        [Newtonsoft.Json.JsonProperty("widget_type", Required = Newtonsoft.Json.Required.Always)]
        public string WidgetType { get; set; }
    }

    public class HeaderWidget : Widget
    {
        public const string WIDGET_TYPE = "HEADER";

        public HeaderWidget()
        {
            WidgetType = WIDGET_TYPE;
        }

        [Newtonsoft.Json.JsonProperty("text", Required = Newtonsoft.Json.Required.Always)]
        public string Text { get; set; }
    }

    [ExcludeFromCodeCoverage]
    public class NameWidget : Widget
    {
        public const string WIDGET_TYPE = "NAME";

        public NameWidget()
        {
            WidgetType = WIDGET_TYPE;
        }

        [Newtonsoft.Json.JsonProperty("label", Required = Newtonsoft.Json.Required.Always)]
        public WidgetLabel Label { get; set; }

        [Newtonsoft.Json.JsonProperty("placeholder_last_name", Required = Newtonsoft.Json.Required.Always)]
        public string PlaceholderLastName { get; set; }

        [Newtonsoft.Json.JsonProperty("placeholder_first_name", Required = Newtonsoft.Json.Required.Always)]
        public string PlaceholderFirstName { get; set; }
    }

public abstract class BasePricingModel {} // can drop `abstract` (or be an interface) if necessary

public class CustomPricingModel : BasePricingModel
{
    public string Value { get; set; }
    public string Caption { get; set; }
}


public class SubscriptionPricingModel : BasePricingModel
{
    public string Period { get; set; }
    public int Duration { get; set; }
}

public enum EnumType
{
    EnumMemberOne,
    EnumMemberTwo
}

public interface IMyType
{
    EnumType EnumValue {get;}
}

public class MyTypeOne : IMyType
{
    public EnumType EnumValue => EnumType.EnumMemberOne;
}

public class MyTypeTwo : IMyType
{
    public EnumType EnumValue => EnumType.EnumMemberTwo;
}

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

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

[JsonConverter(typeof(JsonSubtypes), "searchType")]
[JsonSubtypes.KnownSubType(typeof(CountrySearchDto), "country")]
[JsonSubtypes.KnownSubType(typeof(StateSearchDto), "state")]
public class SearchDto
{
    public string SearchType { get; set; }
}

public class CountrySearchDto : SearchDto
{
}

public class StateSearchDto : SearchDto
{
}

[Newtonsoft.Json.JsonConverter(typeof(JsonInheritanceConverter), "SearchType")]
[JsonInheritanceAttribute("CountrySearchDto", typeof(CountrySearchDto))]
[JsonInheritanceAttribute("SearchSearchDto", typeof(StateSearchDto))]
[System.CodeDom.Compiler.GeneratedCode("NJsonSchema", "9.13.18.0 (Newtonsoft.Json v12.0.0.0)")]
public partial class SearchDto
{
    [Newtonsoft.Json.JsonProperty("searchType", Required = Newtonsoft.Json.Required.Default, NullValueHandling = Newtonsoft.Json.NullValueHandling.Ignore)]
    public string SearchType { get; set; }

    public string ToJson()
    {
        return Newtonsoft.Json.JsonConvert.SerializeObject(this);
    }

    public static SearchDto FromJson(string data)
    {
        return Newtonsoft.Json.JsonConvert.DeserializeObject<SearchDto>(data);
    }
}

var discriminator = Newtonsoft.Json.Linq.Extensions.Value<string>(jObject.GetValue(_discriminator));

void Main()
{
	var o = JsonConvert.DeserializeObject<Base>(@"{""type"": ""UnKnown1""}");
	o.Dump();
}

// Define other methods and classes here
enum Types
{
	Known1,
	Known2,
	UnKnown1,
	UnKnown2,
	UnKnown3
}

[JsonConverter(typeof(JsonSubtypes), "type")]
[JsonSubtypes.KnownSubType(typeof(Known1), Types.Known1)]
[JsonSubtypes.KnownSubType(typeof(Known2), Types.Known2)]
[JsonSubtypes.KnownSubType(typeof(Unknown), Types.UnKnown1)] // <<- How to avoid this?
[JsonSubtypes.KnownSubType(typeof(Unknown), Types.UnKnown2)] // <<- How to avoid this?
[JsonSubtypes.KnownSubType(typeof(Unknown), Types.UnKnown3)] // <<- How to avoid this?
class Base 
{
	public Types Type { get; set; }
}
class Unknown : Base
{
	
}
class Known1 : Base
{
	
}
class Known2 : Base
{

}

[JsonConverter(typeof(JsonSubtypes), "Kind")]
public interface IAnimal
{
    string Kind { get; }
}

public class Dog : IAnimal
{
    public string Kind { get; } = "Dog";
    public string Breed { get; set; }
}

public class Cat : IAnimal {   // SCS0535 'Cat' does not implement interface member 'IAnimal.Kind'	

    public bool Declawed { get; set;}
}

	[JsonConverter(typeof(JsonSubtypes), nameof(Kind))]
	[JsonSubtypes.KnownSubType(typeof(ImplementationA1), "a1")]
	[JsonSubtypes.KnownSubType(typeof(ImplementationA2), "a2")]
	public interface IInterfaceA
	{
		string Kind { get; }
		IInterfaceB SubObject { get; set; }
	}

	public class ImplementationA1 : IInterfaceA
	{
		public string Kind { get; set; } = "a1";
		public IInterfaceB SubObject { get; set; }
	}

	public class ImplementationA2 : IInterfaceA
	{
		public string Kind { get; set; } = "a2";
		public IInterfaceB SubObject { get; set; }
	}

	[JsonConverter(typeof(JsonSubtypes), nameof(Kind))]
	[JsonSubtypes.KnownSubType(typeof(ImplementationB1), "b1")]
	[JsonSubtypes.KnownSubType(typeof(ImplementationB2), "b2")]
	public interface IInterfaceB
	{
		string Kind { get; }
		int Value { get; set; }
	}

	public class ImplementationB1 : IInterfaceB
	{
		public string Kind { get; set; } = "b1";
		public int Value { get; set; }
	}

	public class ImplementationB2 : IInterfaceB
	{
		public string Kind { get; set; } = "b2";
		public int Value { get; set; }
	}

	private static string serialize<T>(T obj) {
		using (var memoryStream = new MemoryStream())
		using (var streamWriter = new StreamWriter(memoryStream))
		using (var jsonTextWriter = new JsonTextWriter(streamWriter))
		{
			var serializer = new JsonSerializer();
			serializer.Serialize(jsonTextWriter, obj);
			return Encoding.UTF8.GetString(memoryStream.ToArray());
		}
	}

	var obj = new ImplementationA1
	{
		SubObject = new ImplementationB1
		{
			Value = 10,
		},
	};

	Assert.AreNotEqual("", serialize(obj));

[JsonConverter(typeof(JsonSubTypes.JsonSubtypes), "Discriminator")]
abstract class Base {
	
}

class Derived : Base {
	public string Discriminator => "Derived";
}

JsonConvert.DeserializeObject<Base>("{\"Discriminator\":\"Base\"}")

-#if (NET35 || NET40)

-#else

-#endif

public interface IAnimal
{
    string Breed {get;set;}
}

[JsonSubType(typeof(IAnimal), PropertyName="Breed", PropertyValue="Dog")]
public class Dog : IAnimal
{
   public string Breed {get;set;} = "Dog";
   public bool HasChip {get;set;}
}

[JsonSubType(typeof(IAnimal), PropertyName="Breed", PropertyValue="Cat")]
public class Cat : IAnimal
{
   public string Breed {get;set;} = "Cat";
   public bool HasClaws {get;set;}
}

public class DtoTest
{
	[Fact]
	public void FooParsing()
	{
		CheckDeserialization<Foo>("{\"msgType\":\"1\"}");
	}

	private static void CheckDeserialization<T>(string json) where T : class 
	{
		var result = JsonConvert.DeserializeObject<DtoBase>(json);
		Assert.IsType<T>(result);
	}
}

[JsonConverter(typeof(JsonSubtypes), nameof(DtoBase.MsgType))]
[JsonSubtypes.KnownSubType(typeof(Foo), 1)]
public abstract class DtoBase
{
	public virtual int MsgType { get; }
}

class Foo : DtoBase
{
	public override int MsgType { get; } = 1;
}

using System;
using Newtonsoft.Json;
using JsonSubTypes;

namespace Test60
{
    class Program
    {
        static void Main(string[] args)
        {
            Payload run = new Payload.Game.Run();
            var data = JsonConvert.SerializeObject(run);
            Console.WriteLine(data);
            var run2 = JsonConvert.DeserializeObject<Payload>(data);
            Console.WriteLine("Hello World!");
        }
    }
    [JsonConverter(typeof(JsonSubTypes.JsonSubtypes), _payloadKind)]
    [JsonSubtypes.KnownSubType(typeof(Payload.Game), Discriminator.GAME)]
    [JsonSubtypes.KnownSubType(typeof(Payload.Com), Discriminator.COM)]
    public abstract partial class Payload
    {
        public const string _payloadKind = "$PayloadKind";

        [JsonProperty(_payloadKind)]
        protected abstract Discriminator PayloadKind { get; }
        public Discriminator Kind => this.PayloadKind;
        public enum Discriminator
        {
            COM = 0,
            GAME = 1
        }
    }
    partial class Payload
    {
        [JsonConverter(typeof(JsonSubTypes.JsonSubtypes), GAMEKIND)]
        [JsonSubTypes.JsonSubtypes.KnownSubType(typeof(Game.Run), Discriminator.RUN)]
        [JsonSubTypes.JsonSubtypes.KnownSubType(typeof(Game.Walk), Discriminator.WALK)]
        public abstract partial class Game : Payload
        {
            protected override Payload.Discriminator PayloadKind => Payload.Discriminator.GAME;
            public new enum Discriminator
            {
                RUN = 0,
                WALK = 1
            }
            public const string GAMEKIND = "$GameKind";
            [JsonProperty(GAMEKIND)]
            protected abstract Discriminator GameKind { get; }
            public new Discriminator Kind => this.GameKind;
        }
    }


    partial class Payload
    {
        public abstract class Com : Payload
        {

        }
    }
    partial class Payload
    {
        partial class Game
        {
            public class Walk : Game
            {
                protected override Discriminator GameKind => Discriminator.WALK;
            }
        }
    }

    partial class Payload
    {
        partial class Game
        {
            public class Run : Game
            {
                protected override Discriminator GameKind => Discriminator.RUN;
            }
        }
    }
}