การหล่ออินเทอร์เฟซสำหรับ deserialization ใน JSON.NET

ฉันกำลังพยายามตั้งค่าเครื่องอ่านที่จะรับวัตถุ JSON จากเว็บไซต์ต่างๆ (คิดว่าการขูดข้อมูล) และแปลเป็นวัตถุ C # ฉันกำลังใช้ JSON.NET สำหรับกระบวนการ deserialization ปัญหาที่ฉันพบคือไม่ทราบวิธีจัดการคุณสมบัติระดับอินเตอร์เฟสในคลาส ดังนั้นบางอย่างของธรรมชาติ:

public IThingy Thing

จะทำให้เกิดข้อผิดพลาด:

ไม่สามารถสร้างอินสแตนซ์ประเภท IThingy Type เป็นอินเทอร์เฟซหรือคลาสนามธรรมและไม่สามารถสร้างอินสแตนซ์ได้

มันค่อนข้างสำคัญที่จะต้องเป็น IThingy เมื่อเทียบกับ Thingy เนื่องจากโค้ดที่ฉันกำลังทำงานอยู่นั้นถือว่ามีความละเอียดอ่อนและการทดสอบหน่วยเป็นสิ่งที่สำคัญมาก การจำลองวัตถุสำหรับสคริปต์ทดสอบอะตอมไม่สามารถทำได้กับวัตถุที่มีคุณสมบัติครบถ้วนเช่น Thingy ต้องเป็นอินเทอร์เฟซ

ฉันอ่านเอกสารของ JSON.NET มาระยะหนึ่งแล้วและคำถามที่ฉันพบในไซต์นี้ที่เกี่ยวข้องกับเรื่องนี้ล้วนมาจากปีที่แล้ว ความช่วยเหลือใด ๆ

นอกจากนี้หากเป็นเรื่องสำคัญแอปของฉันเขียนด้วย. NET 4.0

@SamualDavis ให้คำตอบที่ดีในคำถามที่เกี่ยวข้องซึ่งฉันจะสรุปที่นี่

หากคุณต้อง deserialize สตรีม JSON ลงในคลาสคอนกรีตที่มีคุณสมบัติอินเทอร์เฟซคุณสามารถรวมคลาสคอนกรีตเป็นพารามิเตอร์ให้กับคอนสตรัคเตอร์สำหรับคลาสได้! NewtonSoft deserializer ฉลาดพอที่จะคิดออกว่าจำเป็นต้องใช้คลาสคอนกรีตเหล่านั้นเพื่อแยกค่าคุณสมบัติ

นี่คือตัวอย่าง:

public class Visit : IVisit
{
    /// <summary>
    /// This constructor is required for the JSON deserializer to be able
    /// to identify concrete classes to use when deserializing the interface properties.
    /// </summary>
    public Visit(MyLocation location, Guest guest)
    {
        Location = location;
        Guest = guest;
    }
    public long VisitId { get; set; }
    public ILocation Location { get;  set; }
    public DateTime VisitDate { get; set; }
    public IGuest Guest { get; set; }
}

(คัดลอกมาจากคำถามนี้ )

ในกรณีที่ฉันไม่สามารถควบคุม JSON ที่เข้ามาได้ (ดังนั้นจึงไม่สามารถมั่นใจได้ว่ามีคุณสมบัติ $ type) ฉันได้เขียนตัวแปลงที่กำหนดเองซึ่งช่วยให้คุณระบุประเภทคอนกรีตได้อย่างชัดเจน:

public class Model
{
    [JsonConverter(typeof(ConcreteTypeConverter<Something>))]
    public ISomething TheThing { get; set; }
}

เพียงแค่ใช้การใช้งาน serializer เริ่มต้นจาก Json.Net ในขณะที่ระบุประเภทคอนกรีตอย่างชัดเจน

ภาพรวมมีอยู่ในโพสต์บล็อกนี้ ซอร์สโค้ดอยู่ด้านล่าง:

public class ConcreteTypeConverter<TConcrete> : JsonConverter
{
    public override bool CanConvert(Type objectType)
    {
        //assume we can convert to anything for now
        return true;
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        //explicitly specify the concrete type we want to create
        return serializer.Deserialize<TConcrete>(reader);
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        //use the default serialization - it works fine
        serializer.Serialize(writer, value);
    }
}

ทำไมต้องใช้ตัวแปลง? มีฟังก์ชันดั้งเดิมในNewtonsoft.Jsonการแก้ปัญหานี้:

การตั้งค่าTypeNameHandlingในJsonSerializerSettingsการTypeNameHandling.Auto

JsonConvert.SerializeObject(
  toSerialize,
  new JsonSerializerSettings()
  {
    TypeNameHandling = TypeNameHandling.Auto
  });

สิ่งนี้จะใส่ทุกประเภทลงใน json ซึ่งไม่ได้ถือเป็นตัวอย่างที่เป็นรูปธรรมของประเภท แต่เป็นอินเทอร์เฟซหรือคลาสนามธรรม

ตรวจสอบให้แน่ใจว่าคุณใช้การตั้งค่าเดียวกันสำหรับการทำให้เป็นอนุกรมและการดีซีเรียลไลเซชัน

ฉันทดสอบแล้วและมันใช้งานได้อย่างมีเสน่ห์แม้กระทั่งกับรายการ

Search Results ผลการค้นหาเว็บที่มีลิงค์ของเว็บไซต์

⚠️ คำเตือน :

ใช้สิ่งนี้สำหรับ json จากแหล่งที่รู้จักและเชื่อถือได้เท่านั้น ผู้ใช้snipsnipsnipกล่าวอย่างถูกต้องว่านี่เป็นความสามารถในการทำงาน

ดูCA2328และSCS0028สำหรับข้อมูลเพิ่มเติม

แหล่งที่มาและการใช้งานด้วยตนเองทางเลือก: Code Inside Blog

ในการเปิดใช้งาน deserialization ของการใช้งานอินเทอร์เฟซหลาย ๆ ตัวคุณสามารถใช้ JsonConverter แต่ไม่ต้องใช้แอตทริบิวต์:

Newtonsoft.Json.JsonSerializer serializer = new Newtonsoft.Json.JsonSerializer();
serializer.Converters.Add(new DTOJsonConverter());
Interfaces.IEntity entity = serializer.Deserialize(jsonReader);

DTOJsonConverter แมปแต่ละอินเทอร์เฟซด้วยการนำไปใช้อย่างเป็นรูปธรรม:

class DTOJsonConverter : Newtonsoft.Json.JsonConverter
{
    private static readonly string ISCALAR_FULLNAME = typeof(Interfaces.IScalar).FullName;
    private static readonly string IENTITY_FULLNAME = typeof(Interfaces.IEntity).FullName;


    public override bool CanConvert(Type objectType)
    {
        if (objectType.FullName == ISCALAR_FULLNAME
            || objectType.FullName == IENTITY_FULLNAME)
        {
            return true;
        }
        return false;
    }

    public override object ReadJson(Newtonsoft.Json.JsonReader reader, Type objectType, object existingValue, Newtonsoft.Json.JsonSerializer serializer)
    {
        if (objectType.FullName == ISCALAR_FULLNAME)
            return serializer.Deserialize(reader, typeof(DTO.ClientScalar));
        else if (objectType.FullName == IENTITY_FULLNAME)
            return serializer.Deserialize(reader, typeof(DTO.ClientEntity));

        throw new NotSupportedException(string.Format("Type {0} unexpected.", objectType));
    }

    public override void WriteJson(Newtonsoft.Json.JsonWriter writer, object value, Newtonsoft.Json.JsonSerializer serializer)
    {
        serializer.Serialize(writer, value);
    }
}

DTOJsonConverter จำเป็นสำหรับ deserializer เท่านั้น กระบวนการทำให้เป็นอนุกรมไม่มีการเปลี่ยนแปลง วัตถุ Json ไม่จำเป็นต้องฝังชื่อชนิดคอนกรีต

โพสต์ SOนี้นำเสนอโซลูชันเดียวกันอีกขั้นหนึ่งด้วย JsonConverter ทั่วไป

ใช้คลาสนี้เพื่อจับคู่ประเภทนามธรรมกับประเภทจริง:

public class AbstractConverter<TReal, TAbstract> : JsonConverter where TReal : TAbstract
{
    public override Boolean CanConvert(Type objectType) 
        => objectType == typeof(TAbstract);

    public override Object ReadJson(JsonReader reader, Type type, Object value, JsonSerializer jser) 
        => jser.Deserialize<TReal>(reader);

    public override void WriteJson(JsonWriter writer, Object value, JsonSerializer jser) 
        => jser.Serialize(writer, value);
}

... และเมื่อ deserialize:

        var settings = new JsonSerializerSettings
        {
            Converters = {
                new AbstractConverter<Thing, IThingy>(),
                new AbstractConverter<Thing2, IThingy2>()
            },
        };

        JsonConvert.DeserializeObject(json, type, settings);

Nicholas Westby เป็นทางออกที่ยอดเยี่ยมในบทความที่ยอดเยี่ยม

หากคุณต้องการ Deserializing JSON เป็นหนึ่งในหลาย ๆ คลาสที่เป็นไปได้ที่ใช้อินเทอร์เฟซเช่นนั้น:

public class Person
{
    public IProfession Profession { get; set; }
}

public interface IProfession
{
    string JobTitle { get; }
}

public class Programming : IProfession
{
    public string JobTitle => "Software Developer";
    public string FavoriteLanguage { get; set; }
}

public class Writing : IProfession
{
    public string JobTitle => "Copywriter";
    public string FavoriteWord { get; set; }
}

public class Samples
{
    public static Person GetProgrammer()
    {
        return new Person()
        {
            Profession = new Programming()
            {
                FavoriteLanguage = "C#"
            }
        };
    }
}

คุณสามารถใช้ตัวแปลง JSON แบบกำหนดเอง:

public class ProfessionConverter : JsonConverter
{
    public override bool CanWrite => false;
    public override bool CanRead => true;
    public override bool CanConvert(Type objectType)
    {
        return objectType == typeof(IProfession);
    }
    public override void WriteJson(JsonWriter writer,
        object value, JsonSerializer serializer)
    {
        throw new InvalidOperationException("Use default serialization.");
    }

    public override object ReadJson(JsonReader reader,
        Type objectType, object existingValue,
        JsonSerializer serializer)
    {
        var jsonObject = JObject.Load(reader);
        var profession = default(IProfession);
        switch (jsonObject["JobTitle"].Value())
        {
            case "Software Developer":
                profession = new Programming();
                break;
            case "Copywriter":
                profession = new Writing();
                break;
        }
        serializer.Populate(jsonObject.CreateReader(), profession);
        return profession;
    }
}

และคุณจะต้องตกแต่งคุณสมบัติ "Profession" ด้วยแอตทริบิวต์ JsonConverter เพื่อแจ้งให้ใช้ตัวแปลงที่กำหนดเองของคุณ:

    public class Person
    {
        [JsonConverter(typeof(ProfessionConverter))]
        public IProfession Profession { get; set; }
    }

จากนั้นคุณสามารถแคสต์คลาสของคุณด้วยอินเทอร์เฟซ:

Person person = JsonConvert.DeserializeObject<Person>(jsonString);

สองสิ่งที่คุณอาจลอง:

ใช้แบบจำลอง try / parse:

public class Organisation {
  public string Name { get; set; }

  [JsonConverter(typeof(RichDudeConverter))]
  public IPerson Owner { get; set; }
}

public interface IPerson {
  string Name { get; set; }
}

public class Tycoon : IPerson {
  public string Name { get; set; }
}

public class Magnate : IPerson {
  public string Name { get; set; }
  public string IndustryName { get; set; }
}

public class Heir: IPerson {
  public string Name { get; set; }
  public IPerson Benefactor { get; set; }
}

public class RichDudeConverter : JsonConverter
{
  public override bool CanConvert(Type objectType)
  {
    return (objectType == typeof(IPerson));
  }

  public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
  {
    // pseudo-code
    object richDude = serializer.Deserialize<Heir>(reader);

    if (richDude == null)
    {
        richDude = serializer.Deserialize<Magnate>(reader);
    }

    if (richDude == null)
    {
        richDude = serializer.Deserialize<Tycoon>(reader);
    }

    return richDude;
  }

  public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
  {
    // Left as an exercise to the reader :)
    throw new NotImplementedException();
  }
}

หรือถ้าคุณสามารถทำได้ในแบบจำลองวัตถุของคุณให้ใช้คลาสพื้นฐานที่เป็นรูปธรรมระหว่าง IPerson และวัตถุใบไม้ของคุณ

ครั้งแรกอาจล้มเหลวในรันไทม์ตัวที่สองต้องการการเปลี่ยนแปลงโมเดลอ็อบเจ็กต์ของคุณและทำให้เอาต์พุตเป็นเนื้อเดียวกันเป็นตัวหารร่วมที่ต่ำที่สุด

ฉันพบว่าสิ่งนี้มีประโยชน์ คุณก็เช่นกัน

ตัวอย่างการใช้งาน

public class Parent
{
    [JsonConverter(typeof(InterfaceConverter<IChildModel, ChildModel>))]
    IChildModel Child { get; set; }
}

ตัวแปลงการสร้างแบบกำหนดเอง

public class InterfaceConverter<TInterface, TConcrete> : CustomCreationConverter<TInterface>
    where TConcrete : TInterface, new()
{
    public override TInterface Create(Type objectType)
    {
        return new TConcrete();
    }
}

เอกสาร Json.NET

สำหรับผู้ที่อาจสงสัยเกี่ยวกับ ConcreteListTypeConverter ที่ Oliver อ้างถึงนี่คือความพยายามของฉัน:

public class ConcreteListTypeConverter<TInterface, TImplementation> : JsonConverter where TImplementation : TInterface 
{
    public override bool CanConvert(Type objectType)
    {
        return true;
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        var res = serializer.Deserialize<List<TImplementation>>(reader);
        return res.ConvertAll(x => (TInterface) x);
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        serializer.Serialize(writer, value);
    }
}

สำหรับสิ่งที่คุ้มค่าฉันต้องจัดการเรื่องนี้ด้วยตัวเองเป็นส่วนใหญ่ วัตถุแต่ละคนมีdeserialize (สตริง jsonStream)วิธีการ ตัวอย่างบางส่วนของมัน:

JObject parsedJson = this.ParseJson(jsonStream);
object thingyObjectJson = (object)parsedJson["thing"];
this.Thing = new Thingy(Convert.ToString(thingyObjectJson));

ในกรณีนี้Thingy (สตริง) ใหม่คือตัวสร้างที่จะเรียกเมธอด Deserialize (string jsonStream)ของประเภทคอนกรีตที่เหมาะสม โครงร่างนี้จะลดลงเรื่อย ๆ จนกว่าคุณจะไปถึงจุดฐานที่ json.NET สามารถจัดการได้

this.Name = (string)parsedJson["name"];
this.CreatedTime = DateTime.Parse((string)parsedJson["created_time"]);

ไปเรื่อย ๆ การตั้งค่านี้ทำให้ฉันสามารถให้การตั้งค่า json.NET ที่สามารถจัดการได้โดยไม่ต้อง refactor ส่วนใหญ่ของไลบรารีเองหรือใช้แบบจำลองการลอง / แยกวิเคราะห์ที่ไม่สะดวกซึ่งจะทำให้ห้องสมุดทั้งหมดของเราจมลงเนื่องจากมีวัตถุจำนวนมากที่เกี่ยวข้อง นอกจากนี้ยังหมายความว่าฉันสามารถจัดการกับการเปลี่ยนแปลง json บนวัตถุเฉพาะได้อย่างมีประสิทธิภาพและฉันไม่จำเป็นต้องกังวลกับทุกสิ่งที่วัตถุสัมผัส มันไม่ได้เป็นทางออกที่ดี แต่ทำงานได้ดีจากการทดสอบหน่วยและการรวมของเรา

สมมติว่าการตั้งค่า autofac ดังต่อไปนี้:

public class AutofacContractResolver : DefaultContractResolver
{
    private readonly IContainer _container;

    public AutofacContractResolver(IContainer container)
    {
        _container = container;
    }

    protected override JsonObjectContract CreateObjectContract(Type objectType)
    {
        JsonObjectContract contract = base.CreateObjectContract(objectType);

        // use Autofac to create types that have been registered with it
        if (_container.IsRegistered(objectType))
        {
           contract.DefaultCreator = () => _container.Resolve(objectType);
        }  

        return contract;
    }
}

จากนั้นสมมติว่าชั้นเรียนของคุณเป็นดังนี้:

public class TaskController
{
    private readonly ITaskRepository _repository;
    private readonly ILogger _logger;

    public TaskController(ITaskRepository repository, ILogger logger)
    {
        _repository = repository;
        _logger = logger;
    }

    public ITaskRepository Repository
    {
        get { return _repository; }
    }

    public ILogger Logger
    {
        get { return _logger; }
    }
}

ดังนั้นการใช้ตัวแก้ไขในการแยกสารอาจเป็นดังนี้:

ContainerBuilder builder = new ContainerBuilder();
builder.RegisterType<TaskRepository>().As<ITaskRepository>();
builder.RegisterType<TaskController>();
builder.Register(c => new LogService(new DateTime(2000, 12, 12))).As<ILogger>();

IContainer container = builder.Build();

AutofacContractResolver contractResolver = new AutofacContractResolver(container);

string json = @"{
      'Logger': {
        'Level':'Debug'
      }
}";

// ITaskRespository and ILogger constructor parameters are injected by Autofac 
TaskController controller = JsonConvert.DeserializeObject<TaskController>(json, new JsonSerializerSettings
{
    ContractResolver = contractResolver
});

Console.WriteLine(controller.Repository.GetType().Name);

สามารถดูรายละเอียดเพิ่มเติมได้ในhttp://www.newtonsoft.com/json/help/html/DeserializeWithDependencyInjection.htm

ไม่มีวัตถุใดที่ จะเป็น IThingy ได้เนื่องจากอินเทอร์เฟซเป็นนามธรรมตามคำจำกัดความ

ออบเจ็กต์ที่คุณมีซึ่งถูกทำให้เป็นอนุกรมเป็นครั้งแรกเป็นประเภทคอนกรีตโดยใช้อินเทอร์เฟซนามธรรม คุณต้องมีคลาสคอนกรีตเดียวกันนี้ในการฟื้นฟูข้อมูลที่เป็นอนุกรม

วัตถุที่เกิดแล้วจะมีบางชนิดที่นำไปปฏิบัตินามธรรมอินเตอร์เฟซที่คุณกำลังมองหา

จากเอกสารดังต่อไปนี้คุณสามารถใช้ได้

(Thingy)JsonConvert.DeserializeObject(jsonString, typeof(Thingy));

เมื่อ deserializing เพื่อแจ้ง JSON.NET เกี่ยวกับประเภทคอนกรีต

วิธีแก้ปัญหาของฉันสำหรับสิ่งนี้ซึ่งฉันชอบเพราะเป็นเรื่องทั่วไปมีดังนี้:

/// <summary>
/// Automagically convert known interfaces to (specific) concrete classes on deserialisation
/// </summary>
public class WithMocksJsonConverter : JsonConverter
{
    /// <summary>
    /// The interfaces I know how to instantiate mapped to the classes with which I shall instantiate them, as a Dictionary.
    /// </summary>
    private readonly Dictionary<Type,Type> conversions = new Dictionary<Type,Type>() { 
        { typeof(IOne), typeof(MockOne) },
        { typeof(ITwo), typeof(MockTwo) },
        { typeof(IThree), typeof(MockThree) },
        { typeof(IFour), typeof(MockFour) }
    };

    /// <summary>
    /// Can I convert an object of this type?
    /// </summary>
    /// <param name="objectType">The type under consideration</param>
    /// <returns>True if I can convert the type under consideration, else false.</returns>
    public override bool CanConvert(Type objectType)
    {
        return conversions.Keys.Contains(objectType);
    }

    /// <summary>
    /// Attempt to read an object of the specified type from this reader.
    /// </summary>
    /// <param name="reader">The reader from which I read.</param>
    /// <param name="objectType">The type of object I'm trying to read, anticipated to be one I can convert.</param>
    /// <param name="existingValue">The existing value of the object being read.</param>
    /// <param name="serializer">The serializer invoking this request.</param>
    /// <returns>An object of the type into which I convert the specified objectType.</returns>
    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        try
        {
            return serializer.Deserialize(reader, this.conversions[objectType]);
        }
        catch (Exception)
        {
            throw new NotSupportedException(string.Format("Type {0} unexpected.", objectType));
        }
    }

    /// <summary>
    /// Not yet implemented.
    /// </summary>
    /// <param name="writer">The writer to which I would write.</param>
    /// <param name="value">The value I am attempting to write.</param>
    /// <param name="serializer">the serializer invoking this request.</param>
    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

}

คุณสามารถแปลงเป็นตัวแปลงทั่วไปได้อย่างเห็นได้ชัดและเล็กน้อยโดยการเพิ่มตัวสร้างซึ่งใช้อาร์กิวเมนต์ประเภท Dictionary <Type, Type> ซึ่งใช้ในการสร้างอินสแตนซ์ของตัวแปรอินสแตนซ์การแปลง

หลายปีที่ผ่านมาและฉันมีปัญหาที่คล้ายกัน ในกรณีของฉันมีอินเทอร์เฟซที่ซ้อนกันมากและการตั้งค่าสำหรับการสร้างคลาสคอนกรีตที่รันไทม์เพื่อให้สามารถทำงานกับคลาสทั่วไปได้

ฉันตัดสินใจที่จะสร้างคลาสพร็อกซีในขณะทำงานที่ห่อหุ้มอ็อบเจ็กต์ที่ส่งคืนโดย Newtonsoft

ข้อดีของแนวทางนี้คือไม่ต้องการการนำคลาสไปใช้อย่างเป็นรูปธรรมและสามารถจัดการกับอินเทอร์เฟซที่ซ้อนกันได้โดยอัตโนมัติ ท่านสามารถดูรายละเอียดเพิ่มเติมเกี่ยวกับเรื่องของฉันบล็อก

using Castle.DynamicProxy;
using Newtonsoft.Json.Linq;
using System;
using System.Reflection;

namespace LL.Utilities.Std.Json
{
    public static class JObjectExtension
    {
        private static ProxyGenerator _generator = new ProxyGenerator();

        public static dynamic toProxy(this JObject targetObject, Type interfaceType) 
        {
            return _generator.CreateInterfaceProxyWithoutTarget(interfaceType, new JObjectInterceptor(targetObject));
        }

        public static InterfaceType toProxy<InterfaceType>(this JObject targetObject)
        {

            return toProxy(targetObject, typeof(InterfaceType));
        }
    }

    [Serializable]
    public class JObjectInterceptor : IInterceptor
    {
        private JObject _target;

        public JObjectInterceptor(JObject target)
        {
            _target = target;
        }
        public void Intercept(IInvocation invocation)
        {

            var methodName = invocation.Method.Name;
            if(invocation.Method.IsSpecialName && methodName.StartsWith("get_"))
            {
                var returnType = invocation.Method.ReturnType;
                methodName = methodName.Substring(4);

                if (_target == null || _target[methodName] == null)
                {
                    if (returnType.GetTypeInfo().IsPrimitive || returnType.Equals(typeof(string)))
                    {

                        invocation.ReturnValue = null;
                        return;
                    }

                }

                if (returnType.GetTypeInfo().IsPrimitive || returnType.Equals(typeof(string)))
                {
                    invocation.ReturnValue = _target[methodName].ToObject(returnType);
                }
                else
                {
                    invocation.ReturnValue = ((JObject)_target[methodName]).toProxy(returnType);
                }
            }
            else
            {
                throw new NotImplementedException("Only get accessors are implemented in proxy");
            }

        }
    }



}

การใช้งาน:

var jObj = JObject.Parse(input);
InterfaceType proxyObject = jObj.toProxy<InterfaceType>();

ใช้JsonKnownTypesนี้ซึ่งเป็นวิธีการใช้ที่คล้ายกันมากเพียงแค่เพิ่มตัวเลือกให้กับ json:

[JsonConverter(typeof(JsonKnownTypeConverter<Interface1>))]
[JsonKnownType(typeof(MyClass), "myClass")]
public interface Interface1
{  }
public class MyClass : Interface1
{
    public string Something;
}

ตอนนี้เมื่อคุณทำให้เป็นซีเรียลไลซ์อ็อบเจ็กต์ใน json จะถูกเพิ่ม"$type"ด้วย"myClass"ค่าและจะใช้สำหรับ deserialize

json:

{"Something":"something", "$type":"derived"}

โซลูชันของฉันถูกเพิ่มองค์ประกอบอินเทอร์เฟซในตัวสร้าง

public class Customer: ICustomer{
     public Customer(Details details){
          Details = details;
     }

     [JsonProperty("Details",NullValueHnadling = NullValueHandling.Ignore)]
     public IDetails Details {get; set;}
}