将JSON反序列化为派生类

Question

{
    "Class1": {
        "Class2": [
            {"Name": "DerivedV1"},
            {"Name": "DerivedV2"},
            {"Name": "DerivedV3"}
        ]
    }
}

JsonConvert.DeserializeObject<Class1>(jsonString, settings);

public class Class1
{
    public List<BaseClass> DerivedClasses { get; set; }
}

public abstract BaseClass
{
    public string Name { get; set; }

    public abstract bool DoSomething;
}

public class DerivedV1 : BaseClass
{
    public override bool DoSomething()
    {
        // Logic here, different for each derived class.
    }
}

When trying to deserialize Class1, I can't figure out how to create the list of derived classed from name. I can't declare something like List BaseClass where BaseClass is abstract and I'm not sure how to use reflection during deserialization within Class2 to determine the derived class from the "name" value. I also looked into ICloneable but didn't get anywhere with it in this context.

Edit:

Here is what I ended up creating and calling from get and set

    public static List<T> DeserializeJObjectsToObjects<T>(IEnumerable<JObject> jObjects, string typeKey, string nameSpaceOfClass)
    {
        Assembly assembly = Assembly.GetExecutingAssembly();
        List<T> convert = new List<T>();

        foreach (var jObject in jObjects)
        {
            JToken typeName;
            jObject.TryGetValue(typeKey, out typeName);
            string fullNameSpace = string.Format(namespaceFormat, nameSpaceOfClass, typeName);
            Type t = Type.GetType(string.Format(fullNameSpace));
            convert.Add((T) Activator.CreateInstance(t));
        }

        return convert;
    }

    public static List<JObject> SerializeObjectsToJObjects<T>(IEnumerable<T> variableObjects )
    {
        List<JObject> convert = new List<JObject>();

        foreach (T variableObject in variableObjects)
        {
            var jsonString = JsonConvert.SerializeObject(variableObject);
            convert.Add(JObject.Parse(jsonString));
        }

        return convert;
    }

Answer 1

First, some notes - I don't use JSonConvert, but there are articles that show you how to do this with. See Json.net serialize/deserialize derived types? , for example. However, you didn't include a json.net tag, so I'm assuming this should hopefully help, or at least point you to the right place.

I used the built in .Net JavaScriptSerializer. You may need to adjust this to work with your input. I created my input based on your code, and my json looks nothing like yours. So, you may still have some work left. I was able to get it working with a SimpleTypeResolver. Code below:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.IO;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Web.Script.Serialization;
using System.Windows.Forms;
using System.Xml.Serialization;

namespace WindowsFormsApplication6
{
public partial class Form1 : Form
{
    public Form1()
    {
        InitializeComponent();
    }

    private void button1_Click(object sender, EventArgs e)
    {
        Class1 oClass = new Class1();
        DerivedV1 v1 = new DerivedV1();
        v1.Name = "DerivedV1";
        oClass.DerivedClasses.Add(v1);
        DerivedV2 v2 = new DerivedV2();
        v2.Name = "DerivedV2";
        oClass.DerivedClasses.Add(v2);
        DerivedV3 v3 = new DerivedV3();
        v3.Name = "DerivedV3";
        oClass.DerivedClasses.Add(v3);
        JavaScriptSerializer ser = new JavaScriptSerializer(new SimpleTypeResolver());
        string sSer = ser.Serialize(oClass);

        var test =ser.Deserialize(sSer,typeof(Class1));
        foreach (var tst in ((Class1)test).DerivedClasses)
        {
            Console.WriteLine(tst.Name + Environment.NewLine);
            Console.WriteLine(tst.GetType().ToString() + Environment.NewLine);
        }
    }
    public class Class1
    {
        public List<BaseClass> DerivedClasses { get; set; }
        public Class1()
        {
            DerivedClasses = new List<BaseClass>();
        }
    }
    public abstract class BaseClass
    {
        public string Name { get; set; }
        private bool _dosom;

        public abstract bool DoSomething();
        public BaseClass(){}
    }       
    public class DerivedV1 : BaseClass
    {
        public override bool DoSomething()
        {
            return true;
            // Logic here, different for each derived class.
        }
    }
    public class DerivedV2 : BaseClass
    {
        public override bool DoSomething()
        {
            return false;
            // Logic here, different for each derived class.
        }
    }
    public class DerivedV3 : BaseClass
    {
        public override bool DoSomething()
        {
            return true;
            // Logic here, different for each derived class.
        }
    }
}
}

my output json (with the SimpleTypeResolver):

{"__type":"WindowsFormsApplication6.Form1+Class1, WindowsFormsApplication6, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null","DerivedClasses":[{"__type":"WindowsFormsApplication6.Form1+DerivedV1, WindowsFormsApplication6, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null","Name":"DerivedV1"},{"__type":"WindowsFormsApplication6.Form1+DerivedV2, WindowsFormsApplication6, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null","Name":"DerivedV2"},{"__type":"WindowsFormsApplication6.Form1+DerivedV3, WindowsFormsApplication6, Version=1.0.0.0, Culture=neutral, PublicKeyToken=null","Name":"DerivedV3"}]}

and without the type resolver, for comparison (causes errors):

{"DerivedClasses":[{"Name":"DerivedV1"},{"Name":"DerivedV2"},{"Name":"DerivedV3"}]}

And once I deserialize (in the for loop, Console.WriteLine)...

DerivedV1

WindowsFormsApplication6.Form1+DerivedV1

DerivedV2

WindowsFormsApplication6.Form1+DerivedV2

DerivedV3

WindowsFormsApplication6.Form1+DerivedV3 

Answer 2

Using this as my solution.

  public static List<T> DeserializeJObjectsToObjects<T>(IEnumerable<JObject> jObjects, string typeKey, string nameSpaceOfClass)
    {
        Assembly assembly = Assembly.GetExecutingAssembly();
        List<T> convert = new List<T>();

        foreach (var jObject in jObjects)
        {
            JToken typeName;
            jObject.TryGetValue(typeKey, out typeName);
            string fullNameSpace = string.Format(nameSpaceFormat, nameSpaceOfClass, typeName);
            Type t = Type.GetType(string.Format(fullNameSpace));
            convert.Add((T) Activator.CreateInstance(t));
        }

        return convert;
    }

    public static List<JObject> SerializeObjectsToJObjects<T>(IEnumerable<T> variableObjects )
    {
        List<JObject> convert = new List<JObject>();

        foreach (T variableObject in variableObjects)
        {
            var jsonString = JsonConvert.SerializeObject(variableObject);
            convert.Add(JObject.Parse(jsonString));
        }

        return convert;
    }