การใช้ตัวแปลง Json.NET เพื่อ deserialize คุณสมบัติ

ฉันมีนิยามคลาสที่มีคุณสมบัติที่ส่งคืนอินเทอร์เฟซ

public class Foo
{ 
    public int Number { get; set; }

    public ISomething Thing { get; set; }
}

การพยายามทำให้คลาส Foo เป็นซีเรียลโดยใช้ Json.NET ทำให้ฉันมีข้อความแสดงข้อผิดพลาด "ไม่สามารถสร้างอินสแตนซ์ประเภท 'ISomething' ได้ไอบางอย่างอาจเป็นอินเทอร์เฟซหรือคลาสนามธรรม"

มีแอตทริบิวต์ Json.NET หรือตัวแปลงที่จะให้ฉันระบุSomethingคลาสคอนกรีตที่จะใช้ระหว่างการดีซีเรียลไลเซชันหรือไม่

สิ่งหนึ่งที่คุณสามารถทำได้กับJson.NETคือ:

var settings = new JsonSerializerSettings();
settings.TypeNameHandling = TypeNameHandling.Objects;

JsonConvert.SerializeObject(entity, Formatting.Indented, settings);

TypeNameHandlingธงจะเพิ่ม$typeคุณสมบัติให้กับ JSON ซึ่งจะช่วยให้ Json.NET ที่จะทราบว่าประเภทคอนกรีตจะต้อง deserialize วัตถุลง สิ่งนี้ช่วยให้คุณสามารถยกเลิกการกำหนดค่าวัตถุในขณะที่ยังคงใช้อินเตอร์เฟสหรือคลาสฐานนามธรรม

อย่างไรก็ตามข้อเสียคือนี่เป็นข้อมูลเฉพาะของ Json.NET สิ่ง$typeนี้จะเป็นประเภทที่มีคุณสมบัติครบถ้วนดังนั้นหากคุณกำลังต่ออนุกรมกับข้อมูลประเภท deserializer จะต้องสามารถเข้าใจได้เช่นกัน

เอกสารประกอบ: Serialization Settings with Json.NET

คุณสามารถบรรลุสิ่งนี้ได้โดยใช้คลาส JsonConverter สมมติว่าคุณมีคลาสที่มีคุณสมบัติอินเตอร์เฟส

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

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

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

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

JsonConverter ของคุณมีหน้าที่รับผิดชอบในการทำให้เป็นอนุกรมและการทำให้เป็นอนุกรมของคุณสมบัติพื้นฐาน

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

  public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
  {
    return serializer.Deserialize<Tycoon>(reader);
  }

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

เมื่อคุณทำงานกับ Organization deserialized ผ่าน Json.Net คุณสมบัติ IPerson สำหรับเจ้าของจะเป็นประเภท Tycoon

แทนที่จะส่งออบเจ็กต์ JsonSerializerSettings ที่กำหนดเองไปยัง JsonConvert.SerializeObject () ด้วยอ็อพชัน TypeNameHandling.Objects ตามที่กล่าวไว้ก่อนหน้านี้คุณสามารถทำเครื่องหมายคุณสมบัติอินเทอร์เฟซเฉพาะนั้นด้วยแอ็ตทริบิวต์ดังนั้น JSON ที่สร้างขึ้นจะไม่ถูกขยายด้วยคุณสมบัติ "$ type" ในทุกวัตถุ:

public class Foo
{
    public int Number { get; set; }

    // Add "$type" property containing type info of concrete class.
    [JsonProperty( TypeNameHandling = TypeNameHandling.Objects )]
    public ISomething { get; set; }
}

ในเวอร์ชันล่าสุดของตัวแปลง Newtonsoft Json ของบุคคลที่สามคุณสามารถตั้งค่าตัวสร้างด้วยประเภทคอนกรีตที่เกี่ยวข้องกับคุณสมบัติที่เชื่อมต่อ

public class Foo
{ 
    public int Number { get; private set; }

    public ISomething IsSomething { get; private set; }

    public Foo(int number, Something concreteType)
    {
        Number = number;
        IsSomething = concreteType;
    }
}

ตราบใดที่บางสิ่งบางอย่างดำเนินการตามสิ่งนี้ควรใช้ นอกจากนี้อย่าใส่คอนสตรัคเตอร์ว่างเริ่มต้นในกรณีที่ตัวแปลง JSon พยายามใช้สิ่งนั้นคุณต้องบังคับให้ใช้ตัวสร้างที่มีชนิดคอนกรีต

ปล. นอกจากนี้ยังช่วยให้คุณตั้งค่าเป็นส่วนตัวได้

มีปัญหาเดียวกันดังนั้นฉันจึงคิดตัวแปลงของตัวเองขึ้นมาซึ่งใช้อาร์กิวเมนต์ประเภทที่รู้จัก

public class JsonKnownTypeConverter : JsonConverter
{
    public IEnumerable<Type> KnownTypes { get; set; }

    public JsonKnownTypeConverter(IEnumerable<Type> knownTypes)
    {
        KnownTypes = knownTypes;
    }

    protected object Create(Type objectType, JObject jObject)
    {
        if (jObject["$type"] != null)
        {
            string typeName = jObject["$type"].ToString();
            return Activator.CreateInstance(KnownTypes.First(x =>typeName.Contains("."+x.Name+",")));
        }

        throw new InvalidOperationException("No supported type");
    }

    public override bool CanConvert(Type objectType)
    {
        if (KnownTypes == null)
            return false;

        return (objectType.IsInterface || objectType.IsAbstract) && KnownTypes.Any(objectType.IsAssignableFrom);
    }

    public override object ReadJson(JsonReader reader, Type objectType, object existingValue, JsonSerializer serializer)
    {
        // Load JObject from stream
        JObject jObject = JObject.Load(reader);
        // Create target object based on JObject
        var target = Create(objectType, jObject);
        // Populate the object properties
        serializer.Populate(jObject.CreateReader(), target);
        return target;
    }

    public override void WriteJson(JsonWriter writer, object value, JsonSerializer serializer)
    {
        throw new NotImplementedException();
    }
}

ฉันกำหนดวิธีการขยายสองวิธีสำหรับการแยกส่วนและการทำให้เป็นอนุกรม:

public static class AltiJsonSerializer
{
    public static T DeserializeJson<T>(this string jsonString, IEnumerable<Type> knownTypes = null)
    {
        if (string.IsNullOrEmpty(jsonString))
            return default(T);

        return JsonConvert.DeserializeObject<T>(jsonString,
                new JsonSerializerSettings
                {
                    TypeNameHandling = TypeNameHandling.Auto, 
                    Converters = new List<JsonConverter>
                        (
                            new JsonConverter[]
                            {
                                new JsonKnownTypeConverter(knownTypes)
                            }
                        )
                }
            );
    }

    public static string SerializeJson(this object objectToSerialize)
    {
        return JsonConvert.SerializeObject(objectToSerialize, Formatting.Indented,
        new JsonSerializerSettings {TypeNameHandling = TypeNameHandling.Auto});
    }
}

คุณสามารถกำหนดวิธีการเปรียบเทียบและระบุประเภทของคุณเองในการแปลงฉันใช้ชื่อคลาสเท่านั้น

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

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

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

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

ฉันแค่ต้องการทำตัวอย่างที่ @Daniel T. แสดงให้เราเห็นด้านบน:

หากคุณใช้รหัสนี้เพื่อทำให้เป็นอนุกรมวัตถุของคุณ:

var settings = new JsonSerializerSettings();
settings.TypeNameHandling = TypeNameHandling.Objects;
JsonConvert.SerializeObject(entity, Formatting.Indented, settings);

รหัสสำหรับ deserialize json ควรมีลักษณะดังนี้:

var settings = new JsonSerializerSettings(); 
settings.TypeNameHandling = TypeNameHandling.Objects;
var entity = JsonConvert.DeserializeObject<EntityType>(json, settings);

นี่คือวิธีที่ json สอดคล้องเมื่อใช้TypeNameHandlingแฟล็ก:

ฉันเคยสงสัยในสิ่งเดียวกันนี้ แต่ฉันกลัวว่าจะทำไม่ได้

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

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

นี่คือการอ้างอิงถึงบทความที่เขียนโดย ScottGu

จากนั้นฉันจึงเขียนโค้ดบางอย่างซึ่งคิดว่าอาจเป็นประโยชน์

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

}

public class School : IEducationalInstitute
{
    private string name;
    #region IEducationalInstitute Members

    public string Name
    {
        get { return name; }
        set { name = value; }
    }

    #endregion
}

public class Student 
{
    public IEducationalInstitute LocalSchool { get; set; }

    public int ID { get; set; }
}

public static class JSONHelper
{
    public static string ToJSON(this object obj)
    {
        JavaScriptSerializer serializer = new JavaScriptSerializer();
        return serializer.Serialize(obj);
    }
    public  static string ToJSON(this object obj, int depth)
    {
        JavaScriptSerializer serializer = new JavaScriptSerializer();
        serializer.RecursionLimit = depth;
        return serializer.Serialize(obj);
    }
}

และนี่คือวิธีที่คุณจะเรียกมัน

School myFavSchool = new School() { Name = "JFK High School" };
Student sam = new Student()
{
    ID = 1,
    LocalSchool = myFavSchool
};
string jSONstring = sam.ToJSON();

Console.WriteLine(jSONstring);
//Result {"LocalSchool":{"Name":"JFK High School"},"ID":1}

ถ้าฉันเข้าใจถูกต้องฉันไม่คิดว่าคุณจะต้องระบุคลาสคอนกรีตที่ใช้อินเทอร์เฟซสำหรับการทำให้อนุกรม JSON